@adventurelabs/scout-core 1.4.95 → 1.5.0

package/dist/helpers/client_abilities_jwt_keys_internal.js

@@ -0,0 +1,20 @@
+import { IWebResponse } from "../types/requests";
+export async function upsert_client_abilities_jwt_public_key(client, kid, publicJwk) {
+    const { error } = await client.rpc("upsert_client_abilities_jwt_public_key", {
+        p_kid: kid,
+        p_public_jwk: publicJwk,
+    });
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    return IWebResponse.success(null).to_compatible();
+}
+export async function revoke_client_abilities_jwt_public_key(client, kid) {
+    const { error } = await client.rpc("revoke_client_abilities_jwt_public_key", {
+        p_kid: kid,
+    });
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    return IWebResponse.success(null).to_compatible();
+}

package/dist/helpers/client_abilities_token_server.d.ts

@@ -1,7 +1,3 @@
-import { SupabaseClient } from "@supabase/supabase-js";
-import { Database } from "../types/supabase";
 import { IClientAbilitiesTokenMint } from "../types/client_abilities_token";
 import { IWebResponseCompatible } from "../types/requests";
-export declare function server_mint_client_abilities_token(options?: {
-    client?: SupabaseClient<Database>;
-}): Promise<IWebResponseCompatible<IClientAbilitiesTokenMint>>;
+export declare function server_mint_client_abilities_token(): Promise<IWebResponseCompatible<IClientAbilitiesTokenMint>>;

package/dist/helpers/client_abilities_token_server.js

@@ -1,7 +1,7 @@
 "use server";
 import { newServerClient } from "../supabase/server";
 import { mint_client_abilities_token } from "./client_abilities_token";
-export async function server_mint_client_abilities_token(options) {
-    const client = options?.client ?? (await newServerClient());
+export async function server_mint_client_abilities_token() {
+    const client = await newServerClient();
     return mint_client_abilities_token(client);
 }

package/dist/helpers/connectivity.d.ts

@@ -1,14 +1,13 @@
 import { IWebResponseCompatible } from "../types/requests";
 import { IConnectivityWithCoordinates, IConnectivity, ConnectivityInsert, ConnectivityUpdate } from "../types/db";
-import { SupabaseClient } from "@supabase/supabase-js";
 export declare function server_get_connectivity_by_session_id(sessionId: number): Promise<IWebResponseCompatible<IConnectivityWithCoordinates[]>>;
 export declare function server_get_connectivity_by_device_id(deviceId: number, timestamp: string): Promise<IWebResponseCompatible<IConnectivityWithCoordinates[]>>;
-export declare function server_insert_connectivity(connectivity: ConnectivityInsert | ConnectivityInsert[], client?: SupabaseClient): Promise<IWebResponseCompatible<IConnectivity[]>>;
+export declare function server_insert_connectivity(connectivity: ConnectivityInsert | ConnectivityInsert[]): Promise<IWebResponseCompatible<IConnectivity[]>>;
 export declare function server_update_connectivity(connectivity: (ConnectivityUpdate & {
     id: number;
 }) | (ConnectivityUpdate & {
     id: number;
-})[], client?: SupabaseClient): Promise<IWebResponseCompatible<IConnectivity[]>>;
+})[]): Promise<IWebResponseCompatible<IConnectivity[]>>;
 /** Pagination info returned with herd time range connectivity. */
 export type HerdConnectivityTimeRangeResponse = IWebResponseCompatible<IConnectivityWithCoordinates[]> & {
     hasMore: boolean;

package/dist/helpers/connectivity.internal.d.ts

@@ -0,0 +1,10 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { IConnectivity, ConnectivityInsert, ConnectivityUpdate } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+import type { Database } from "../types/supabase";
+export declare function insertConnectivityWithClient(client: SupabaseClient<Database>, connectivity: ConnectivityInsert | ConnectivityInsert[]): Promise<IWebResponseCompatible<IConnectivity[]>>;
+export declare function updateConnectivityWithClient(client: SupabaseClient<Database>, connectivity: (ConnectivityUpdate & {
+    id: number;
+}) | (ConnectivityUpdate & {
+    id: number;
+})[]): Promise<IWebResponseCompatible<IConnectivity[]>>;

package/dist/helpers/connectivity.internal.js

@@ -0,0 +1,47 @@
+import { EnumWebResponse, IWebResponse, } from "../types/requests";
+export async function insertConnectivityWithClient(client, connectivity) {
+    const connectivityArray = Array.isArray(connectivity)
+        ? connectivity
+        : [connectivity];
+    const { data, error } = await client
+        .from("connectivity")
+        .insert(connectivityArray)
+        .select("*");
+    if (error) {
+        console.warn("Error inserting connectivity:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: [],
+        };
+    }
+    return IWebResponse.success(data || []).to_compatible();
+}
+export async function updateConnectivityWithClient(client, connectivity) {
+    const connectivityArray = Array.isArray(connectivity)
+        ? connectivity
+        : [connectivity];
+    const updatedConnectivity = [];
+    for (const record of connectivityArray) {
+        const { id, ...updateData } = record;
+        delete updateData.inserted_at;
+        const { data, error } = await client
+            .from("connectivity")
+            .update(updateData)
+            .eq("id", id)
+            .select("*")
+            .single();
+        if (error) {
+            console.warn("Error updating connectivity:", error.message);
+            return {
+                status: EnumWebResponse.ERROR,
+                msg: error.message,
+                data: [],
+            };
+        }
+        if (data) {
+            updatedConnectivity.push(data);
+        }
+    }
+    return IWebResponse.success(updatedConnectivity).to_compatible();
+}

package/dist/helpers/connectivity.js

@@ -45,12 +45,12 @@ export async function server_get_connectivity_by_device_id(deviceId, timestamp)
     return IWebResponse.success(sortedConnectivity).to_compatible();
 }
 // Insert new connectivity records (accepts array for batch operations)
-export async function server_insert_connectivity(connectivity, client) {
-    const supabase = client || (await newServerClient());
+export async function server_insert_connectivity(connectivity) {
+    const client = await newServerClient();
     const connectivityArray = Array.isArray(connectivity)
         ? connectivity
         : [connectivity];
-    const { data, error } = await supabase
+    const { data, error } = await client
         .from("connectivity")
         .insert(connectivityArray)
         .select("*");
@@ -66,17 +66,16 @@ export async function server_insert_connectivity(connectivity, client) {
 }
 // Update existing connectivity records (accepts array for batch operations)
 // Each connectivity record in the array must include an 'id' field
-export async function server_update_connectivity(connectivity, client) {
-    const supabase = client || (await newServerClient());
+export async function server_update_connectivity(connectivity) {
+    const client = await newServerClient();
     const connectivityArray = Array.isArray(connectivity)
         ? connectivity
         : [connectivity];
     const updatedConnectivity = [];
     for (const record of connectivityArray) {
         const { id, ...updateData } = record;
-        // Remove fields that shouldn't be updated
         delete updateData.inserted_at;
-        const { data, error } = await supabase
+        const { data, error } = await client
             .from("connectivity")
             .update(updateData)
             .eq("id", id)

package/dist/helpers/devices.d.ts

@@ -1,8 +1,6 @@
-import { Database } from "../types/supabase";
 import { DeviceInsert, IDevice } from "../types/db";
 import { IWebResponseCompatible } from "../types/requests";
-import { SupabaseClient } from "@supabase/supabase-js";
-export declare function get_devices_by_herd(herd_id: number, client: SupabaseClient<Database>): Promise<IWebResponseCompatible<IDevice[]>>;
+export declare function get_devices_by_herd(herd_id: number): Promise<IWebResponseCompatible<IDevice[]>>;
 export declare function serverUpdateDevice(updatedDevice: IDevice): Promise<IWebResponseCompatible<IDevice | null>>;
 export declare function serverCreateDevice(newDevice: DeviceInsert): Promise<IWebResponseCompatible<IDevice | null>>;
 export declare function serverDeleteDeviceById(device_id: number): Promise<IWebResponseCompatible<IDevice | null>>;

package/dist/helpers/devices.js

@@ -1,18 +1,9 @@
 "use server";
 import { newServerClient } from "../supabase/server";
 import { IWebResponse } from "../types/requests";
-export async function get_devices_by_herd(herd_id, client) {
-    // call get_devices_for_herd with rpc
-    const { data, error } = await client.rpc("get_devices_for_herd", {
-        herd_id_caller: herd_id,
-    });
-    if (!data) {
-        return IWebResponse.error("No devices found").to_compatible();
-    }
-    else {
-        let response = IWebResponse.success(data);
-        return response.to_compatible();
-    }
+import { get_devices_by_herd_query } from "./devices.queries";
+export async function get_devices_by_herd(herd_id) {
+    return get_devices_by_herd_query(await newServerClient(), herd_id);
 }
 export async function serverUpdateDevice(updatedDevice) {
     // delete api keys, latitide, and longitude

package/dist/helpers/devices.queries.d.ts

@@ -0,0 +1,5 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { IDevice } from "../types/db";
+import { Database } from "../types/supabase";
+import { IWebResponseCompatible } from "../types/requests";
+export declare function get_devices_by_herd_query(client: SupabaseClient<Database>, herd_id: number): Promise<IWebResponseCompatible<IDevice[]>>;

package/dist/helpers/devices.queries.js

@@ -0,0 +1,10 @@
+import { IWebResponse } from "../types/requests";
+export async function get_devices_by_herd_query(client, herd_id) {
+    const { data } = await client.rpc("get_devices_for_herd", {
+        herd_id_caller: herd_id,
+    });
+    if (!data) {
+        return IWebResponse.error("No devices found").to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}

package/dist/helpers/embeddings.d.ts

@@ -1,6 +1,5 @@
-import { IWebResponseCompatible } from "../types/requests";
 import type { IEmbeddingSearchResult } from "../types/db";
-import { SupabaseClient } from "@supabase/supabase-js";
+import { IWebResponseCompatible } from "../types/requests";
 /**
  * Semantic search over the embeddings table (embeddings_vertex_multimodal_001).
  * Returns matching embedding row ids with event_id, artifact_id, and confidence.
@@ -8,5 +7,4 @@ import { SupabaseClient } from "@supabase/supabase-js";
  */
 export declare function server_search_embeddings_vertex_multimodal_001(query_embedding: number[], match_threshold: number, match_count: number, options?: {
     herd_id?: number | null;
-    client?: SupabaseClient;
 }): Promise<IWebResponseCompatible<IEmbeddingSearchResult[]>>;

package/dist/helpers/embeddings.internal.d.ts

@@ -0,0 +1,5 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import type { IEmbeddingSearchResult } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+import type { Database } from "../types/supabase";
+export declare function searchEmbeddingsVertexMultimodal001WithClient(client: SupabaseClient<Database>, query_embedding: number[], match_threshold: number, match_count: number, herd_id: number | null | undefined): Promise<IWebResponseCompatible<IEmbeddingSearchResult[]>>;

package/dist/helpers/embeddings.internal.js

@@ -0,0 +1,14 @@
+import { IWebResponse } from "../types/requests";
+export async function searchEmbeddingsVertexMultimodal001WithClient(client, query_embedding, match_threshold, match_count, herd_id) {
+    const rpcName = "search_embeddings_vertex_multimodal_001";
+    const { data, error } = await client.rpc(rpcName, {
+        query_embedding: JSON.stringify(query_embedding),
+        match_threshold,
+        match_count,
+        ...(herd_id != null && { herd_id_caller: herd_id }),
+    });
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    return IWebResponse.success((data ?? [])).to_compatible();
+}

package/dist/helpers/embeddings.js

@@ -7,9 +7,9 @@ import { IWebResponse } from "../types/requests";
  * Use for general embedding search without coupling to events vs artifacts.
  */
 export async function server_search_embeddings_vertex_multimodal_001(query_embedding, match_threshold, match_count, options) {
-    const supabase = options?.client ?? (await newServerClient());
+    const client = await newServerClient();
     const rpcName = "search_embeddings_vertex_multimodal_001";
-    const { data, error } = await supabase.rpc(rpcName, {
+    const { data, error } = await client.rpc(rpcName, {
         query_embedding: JSON.stringify(query_embedding),
         match_threshold,
         match_count,

package/dist/helpers/events.d.ts

@@ -1,18 +1,16 @@
 import { IWebResponseCompatible } from "../types/requests";
 import { EnumSessionsVisibility } from "../types/events";
 import { IEvent, IEventWithMediaUrl, EventInsert, EventUpdate } from "../types/db";
-import { SupabaseClient } from "@supabase/supabase-js";
-export declare function server_get_event_by_id(id: number, client?: SupabaseClient): Promise<IWebResponseCompatible<IEventWithMediaUrl | null>>;
+export declare function server_get_event_by_id(id: number): Promise<IWebResponseCompatible<IEventWithMediaUrl | null>>;
 export declare function server_get_total_events_by_herd(herd_id: number, sessions_visibility: EnumSessionsVisibility): Promise<IWebResponseCompatible<number>>;
-export declare function server_insert_event(events: EventInsert | EventInsert[], client?: SupabaseClient): Promise<IWebResponseCompatible<IEvent[]>>;
+export declare function server_insert_event(events: EventInsert | EventInsert[]): Promise<IWebResponseCompatible<IEvent[]>>;
 export declare function server_update_event(events: (EventUpdate & {
     id: number;
 }) | (EventUpdate & {
     id: number;
-})[], client?: SupabaseClient): Promise<IWebResponseCompatible<IEvent[]>>;
-export declare function server_delete_event(id: number | number[], client?: SupabaseClient): Promise<IWebResponseCompatible<boolean>>;
+})[]): Promise<IWebResponseCompatible<IEvent[]>>;
+export declare function server_delete_event(id: number | number[]): Promise<IWebResponseCompatible<boolean>>;
 /** Semantic search over events using Vertex multimodal embedding (embedding_vertex_mm_01). */
 export declare function server_match_events_by_vertex_embedding(query_embedding: number[], match_threshold: number, match_count: number, options?: {
     herd_id?: number | null;
-    client?: SupabaseClient;
 }): Promise<IWebResponseCompatible<IEvent[]>>;

package/dist/helpers/events.internal.d.ts

@@ -0,0 +1,13 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { IEvent, IEventWithMediaUrl, EventInsert, EventUpdate } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+import type { Database } from "../types/supabase";
+export declare function getEventByIdWithClient(client: SupabaseClient<Database>, id: number): Promise<IWebResponseCompatible<IEventWithMediaUrl | null>>;
+export declare function insertEventWithClient(client: SupabaseClient<Database>, events: EventInsert | EventInsert[]): Promise<IWebResponseCompatible<IEvent[]>>;
+export declare function updateEventWithClient(client: SupabaseClient<Database>, events: (EventUpdate & {
+    id: number;
+}) | (EventUpdate & {
+    id: number;
+})[]): Promise<IWebResponseCompatible<IEvent[]>>;
+export declare function deleteEventWithClient(client: SupabaseClient<Database>, id: number | number[]): Promise<IWebResponseCompatible<boolean>>;
+export declare function matchEventsByVertexEmbeddingWithClient(client: SupabaseClient<Database>, query_embedding: number[], match_threshold: number, match_count: number, herd_id: number | null | undefined): Promise<IWebResponseCompatible<IEvent[]>>;

package/dist/helpers/events.internal.js

@@ -0,0 +1,88 @@
+import { EnumWebResponse, IWebResponse, } from "../types/requests";
+import { generateSignedUrlWithClient } from "./storage_internal";
+import { isNonEmptyStorageFilePath } from "./storagePath";
+export async function getEventByIdWithClient(client, id) {
+    const { data, error } = await client
+        .from("events")
+        .select("*")
+        .eq("id", id)
+        .single();
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.success(null).to_compatible();
+    }
+    const event = data;
+    let media_url = null;
+    if (isNonEmptyStorageFilePath(event.file_path)) {
+        media_url = await generateSignedUrlWithClient(client, event.file_path);
+    }
+    return IWebResponse.success({
+        ...event,
+        media_url,
+    }).to_compatible();
+}
+export async function insertEventWithClient(client, events) {
+    const eventsArray = Array.isArray(events) ? events : [events];
+    const { data, error } = await client
+        .from("events")
+        .insert(eventsArray)
+        .select("*");
+    if (error) {
+        console.warn("Error inserting events:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: [],
+        };
+    }
+    return IWebResponse.success(data || []).to_compatible();
+}
+export async function updateEventWithClient(client, events) {
+    const eventsArray = Array.isArray(events) ? events : [events];
+    const updatedEvents = [];
+    for (const event of eventsArray) {
+        const { id, ...updateData } = event;
+        delete updateData.inserted_at;
+        const { data, error } = await client
+            .from("events")
+            .update(updateData)
+            .eq("id", id)
+            .select("*")
+            .single();
+        if (error) {
+            console.warn("Error updating event:", error.message);
+            return {
+                status: EnumWebResponse.ERROR,
+                msg: error.message,
+                data: [],
+            };
+        }
+        if (data) {
+            updatedEvents.push(data);
+        }
+    }
+    return IWebResponse.success(updatedEvents).to_compatible();
+}
+export async function deleteEventWithClient(client, id) {
+    const ids = Array.isArray(id) ? id : [id];
+    const { error } = await client.from("events").delete().in("id", ids);
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    return IWebResponse.success(true).to_compatible();
+}
+export async function matchEventsByVertexEmbeddingWithClient(client, query_embedding, match_threshold, match_count, herd_id) {
+    const rpcName = "match_events_by_vertex_embedding";
+    const { data, error } = await client.rpc(rpcName, {
+        query_embedding: JSON.stringify(query_embedding),
+        match_threshold,
+        match_count,
+        herd_id_caller: herd_id ?? undefined,
+    });
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    return IWebResponse.success((data ?? [])).to_compatible();
+}

package/dist/helpers/events.js

@@ -2,11 +2,11 @@
 import { newServerClient } from "../supabase/server";
 import { EnumWebResponse, IWebResponse, } from "../types/requests";
 import { EnumSessionsVisibility } from "../types/events";
-import { generateSignedUrl } from "./storage";
+import { generateSignedUrlWithClient } from "./storage_internal";
 import { isNonEmptyStorageFilePath } from "./storagePath";
-export async function server_get_event_by_id(id, client) {
-    const supabase = client || (await newServerClient());
-    const { data, error } = await supabase
+export async function server_get_event_by_id(id) {
+    const client = await newServerClient();
+    const { data, error } = await client
         .from("events")
         .select("*")
         .eq("id", id)
@@ -20,7 +20,7 @@ export async function server_get_event_by_id(id, client) {
     const event = data;
     let media_url = null;
     if (isNonEmptyStorageFilePath(event.file_path)) {
-        media_url = await generateSignedUrl(event.file_path, undefined, client);
+        media_url = await generateSignedUrlWithClient(client, event.file_path);
     }
     return IWebResponse.success({
         ...event,
@@ -48,10 +48,10 @@ export async function server_get_total_events_by_herd(herd_id, sessions_visibili
     }
 }
 // Insert new events (accepts array for batch operations)
-export async function server_insert_event(events, client) {
-    const supabase = client || (await newServerClient());
+export async function server_insert_event(events) {
+    const client = await newServerClient();
     const eventsArray = Array.isArray(events) ? events : [events];
-    const { data, error } = await supabase
+    const { data, error } = await client
         .from("events")
         .insert(eventsArray)
         .select("*");
@@ -67,15 +67,14 @@ export async function server_insert_event(events, client) {
 }
 // Update existing events (accepts array for batch operations)
 // Each event in the array must include an 'id' field
-export async function server_update_event(events, client) {
-    const supabase = client || (await newServerClient());
+export async function server_update_event(events) {
+    const client = await newServerClient();
     const eventsArray = Array.isArray(events) ? events : [events];
     const updatedEvents = [];
     for (const event of eventsArray) {
         const { id, ...updateData } = event;
-        // Remove fields that shouldn't be updated
         delete updateData.inserted_at;
-        const { data, error } = await supabase
+        const { data, error } = await client
             .from("events")
             .update(updateData)
             .eq("id", id)
@@ -95,10 +94,10 @@ export async function server_update_event(events, client) {
     }
     return IWebResponse.success(updatedEvents).to_compatible();
 }
-export async function server_delete_event(id, client) {
-    const supabase = client || (await newServerClient());
+export async function server_delete_event(id) {
+    const client = await newServerClient();
     const ids = Array.isArray(id) ? id : [id];
-    const { error } = await supabase.from("events").delete().in("id", ids);
+    const { error } = await client.from("events").delete().in("id", ids);
     if (error) {
         return IWebResponse.error(error.message).to_compatible();
     }
@@ -106,9 +105,9 @@ export async function server_delete_event(id, client) {
 }
 /** Semantic search over events using Vertex multimodal embedding (embedding_vertex_mm_01). */
 export async function server_match_events_by_vertex_embedding(query_embedding, match_threshold, match_count, options) {
-    const supabase = options?.client ?? (await newServerClient());
+    const client = await newServerClient();
     const rpcName = "match_events_by_vertex_embedding";
-    const { data, error } = await supabase.rpc(rpcName, {
+    const { data, error } = await client.rpc(rpcName, {
         query_embedding: JSON.stringify(query_embedding),
         match_threshold,
         match_count,

package/dist/helpers/herd_allowed_domains.d.ts

@@ -1,5 +1,3 @@
-import { Database } from "../types/supabase";
 import { IHerdAllowedDomain } from "../types/db";
 import { IWebResponseCompatible } from "../types/requests";
-import { SupabaseClient } from "@supabase/supabase-js";
-export declare function server_get_herd_allowed_domains(herd_id: number, supabaseClient?: SupabaseClient<Database>): Promise<IWebResponseCompatible<IHerdAllowedDomain[]>>;
+export declare function server_get_herd_allowed_domains(herd_id: number): Promise<IWebResponseCompatible<IHerdAllowedDomain[]>>;

package/dist/helpers/herd_allowed_domains.js

@@ -1,8 +1,8 @@
 "use server";
 import { newServerClient } from "../supabase/server";
 import { IWebResponse } from "../types/requests";
-export async function server_get_herd_allowed_domains(herd_id, supabaseClient) {
-    const supabase = supabaseClient ?? (await newServerClient());
+export async function server_get_herd_allowed_domains(herd_id) {
+    const supabase = await newServerClient();
     const { data, error } = await supabase
         .from("herd_allowed_domains")
         .select("*")

package/dist/helpers/herd_allowed_domains_internal.d.ts

@@ -0,0 +1,5 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { IHerdAllowedDomain } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+import { Database } from "../types/supabase";
+export declare function getHerdAllowedDomainsWithClient(supabase: SupabaseClient<Database>, herd_id: number): Promise<IWebResponseCompatible<IHerdAllowedDomain[]>>;

package/dist/helpers/herd_allowed_domains_internal.js

@@ -0,0 +1,12 @@
+import { IWebResponse } from "../types/requests";
+export async function getHerdAllowedDomainsWithClient(supabase, herd_id) {
+    const { data, error } = await supabase
+        .from("herd_allowed_domains")
+        .select("*")
+        .eq("herd_id", herd_id)
+        .order("domain", { ascending: true });
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    return IWebResponse.success(data ?? []).to_compatible();
+}

package/dist/helpers/herd_modules.queries.d.ts

@@ -0,0 +1,3 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { IHerdModulesResponseWithStatus } from "../types/herd_module";
+export declare function load_herd_modules_query(client: SupabaseClient): Promise<IHerdModulesResponseWithStatus>;

package/dist/helpers/herd_modules.queries.js

@@ -0,0 +1,106 @@
+import { createHash } from "crypto";
+import { list_api_keys_batch_query } from "../api_keys/queries";
+import { LABELS } from "../constants/annotator";
+import { EnumWebResponse, } from "../types/requests";
+import { get_devices_by_herd_query } from "./devices.queries";
+import { get_herds_with_location_query } from "./herds.queries";
+import { get_layers_by_herd_ids_query, get_plans_by_herd_ids_query, get_providers_by_herd_ids_query, } from "./herd_scoped.queries";
+import { get_parts_by_herd_ids } from "./parts";
+import { get_session_summaries_query } from "./session_summaries.queries";
+import { get_session_usage_over_time_by_herd_query } from "./sessions.queries";
+import { get_users_with_herd_access_batch_query } from "./users.queries";
+import { server_get_more_zones_and_actions_for_herd } from "./zones";
+function hashHerdModules(modules) {
+    const stable = modules.map(({ timestamp_last_refreshed: _ts, ...rest }) => rest);
+    return createHash("sha1").update(JSON.stringify(stable)).digest("hex");
+}
+export async function load_herd_modules_query(client) {
+    const startTime = Date.now();
+    const herdsResult = await get_herds_with_location_query(client);
+    if (herdsResult.status !== EnumWebResponse.SUCCESS || !herdsResult.data) {
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: herdsResult.msg ?? "Failed to load herds",
+            data: null,
+            time_finished: Date.now(),
+            time_sent: Date.now(),
+            server_processing_time_ms: Date.now() - startTime,
+            content_hash: "",
+        };
+    }
+    const herds = herdsResult.data.filter((herd) => herd.id != null);
+    if (herds.length === 0) {
+        const endTime = Date.now();
+        console.log(`[server_load_herd_modules] No accessible herds (${endTime - startTime}ms)`);
+        return {
+            status: EnumWebResponse.SUCCESS,
+            msg: "No herds accessible",
+            data: [],
+            time_finished: endTime,
+            time_sent: endTime,
+            server_processing_time_ms: endTime - startTime,
+            content_hash: hashHerdModules([]),
+        };
+    }
+    const herdIds = herds.map((herd) => herd.id);
+    const perHerd = (query) => Promise.all(herds.map((herd) => query(herd.id).catch(() => ({
+        status: EnumWebResponse.ERROR,
+        msg: "",
+        data: null,
+    }))));
+    const grouped = (query) => query.then((response) => response.data ?? {}).catch(() => ({}));
+    const unwrap = (response) => response.status === EnumWebResponse.SUCCESS ? response.data : null;
+    const [plansByHerd, layersByHerd, providersByHerd, usersByHerd, partsByDevice, devicesResults, zonesResults, summariesResults, usageResults,] = await Promise.all([
+        grouped(get_plans_by_herd_ids_query(client, herdIds)),
+        grouped(get_layers_by_herd_ids_query(client, herdIds)),
+        grouped(get_providers_by_herd_ids_query(client, herdIds)),
+        get_users_with_herd_access_batch_query(client, herdIds)
+            .then(unwrap)
+            .catch(() => null),
+        grouped(get_parts_by_herd_ids(client, herdIds)),
+        perHerd((id) => get_devices_by_herd_query(client, id)),
+        perHerd((id) => server_get_more_zones_and_actions_for_herd(id, 0, 10, client)),
+        perHerd((id) => get_session_summaries_query(client, { herd_id: id })),
+        perHerd((id) => get_session_usage_over_time_by_herd_query(client, id)),
+    ]);
+    const devicesByHerdIndex = devicesResults.map((response) => unwrap(response) ?? []);
+    const allDevices = devicesByHerdIndex.flat();
+    let apiKeysByDevice = {};
+    if (allDevices.length > 0) {
+        try {
+            apiKeysByDevice = await list_api_keys_batch_query(client, allDevices.map((device) => device.id ?? 0));
+        }
+        catch (error) {
+            console.error("[server_load_herd_modules] Failed to load API keys:", error);
+        }
+    }
+    for (const device of allDevices) {
+        const deviceId = device.id ?? 0;
+        device.api_keys_scout = apiKeysByDevice[deviceId] || [];
+        device.parts = partsByDevice[deviceId] || [];
+    }
+    const serialized_herd_modules = herds.map((herd, index) => ({
+        herd,
+        devices: devicesByHerdIndex[index],
+        timestamp_last_refreshed: Date.now(),
+        user_roles: usersByHerd ? usersByHerd[herd.id] ?? [] : null,
+        labels: LABELS,
+        plans: plansByHerd[herd.id] ?? [],
+        zones: unwrap(zonesResults[index]) ?? [],
+        layers: layersByHerd[herd.id] ?? [],
+        providers: providersByHerd[herd.id] ?? [],
+        session_summaries: unwrap(summariesResults[index]),
+        session_usage: unwrap(usageResults[index]),
+    }));
+    const endTime = Date.now();
+    console.log(`[server_load_herd_modules] Loaded ${herds.length} herds in ${endTime - startTime}ms (batched queries)`);
+    return {
+        status: EnumWebResponse.SUCCESS,
+        msg: "Herd modules loaded successfully",
+        data: serialized_herd_modules,
+        time_finished: endTime,
+        time_sent: endTime,
+        server_processing_time_ms: endTime - startTime,
+        content_hash: hashHerdModules(serialized_herd_modules),
+    };
+}