@adventurelabs/scout-core 1.4.83 → 1.4.85

package/dist/api_keys/actions.d.ts

@@ -1,6 +1,7 @@
 import { IApiKeyScout } from "../types/db";
+import { SupabaseClient } from "@supabase/supabase-js";
 export declare function test_api_key_loading(device_id: number): Promise<boolean>;
 export declare function server_list_api_keys(device_id: number): Promise<IApiKeyScout[]>;
-export declare function server_list_api_keys_batch(device_ids: number[]): Promise<{
+export declare function server_list_api_keys_batch(device_ids: number[], client?: SupabaseClient): Promise<{
     [device_id: number]: IApiKeyScout[];
 }>;

package/dist/api_keys/actions.js

@@ -31,8 +31,8 @@ export async function server_list_api_keys(device_id) {
     }
     return data_to_return;
 }
-export async function server_list_api_keys_batch(device_ids) {
-    const supabase = await newServerClient();
+export async function server_list_api_keys_batch(device_ids, client) {
+    const supabase = client || (await newServerClient());
     // Check if the batch function exists by trying a simple call
     try {
         const { data, error } = await supabase.rpc("load_api_keys_batch", {

package/dist/helpers/herd_credentials.d.ts

@@ -0,0 +1,9 @@
+import { Database } from "../types/supabase";
+import { CredentialQueryArgs, IHerdCredential, HerdCredentialInsert, HerdCredentialUpdate } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+import { SupabaseClient } from "@supabase/supabase-js";
+export declare function get_herd_credentials_by_herd_id(client: SupabaseClient<Database>, herd_id: number, args?: CredentialQueryArgs): Promise<IWebResponseCompatible<IHerdCredential[]>>;
+export declare function get_herd_credential_by_id(client: SupabaseClient<Database>, credential_id: number): Promise<IWebResponseCompatible<IHerdCredential | null>>;
+export declare function create_herd_credential(client: SupabaseClient<Database>, row: HerdCredentialInsert): Promise<IWebResponseCompatible<IHerdCredential | null>>;
+export declare function update_herd_credential(client: SupabaseClient<Database>, credential_id: number, patch: HerdCredentialUpdate): Promise<IWebResponseCompatible<IHerdCredential | null>>;
+export declare function delete_herd_credential(client: SupabaseClient<Database>, credential_id: number): Promise<IWebResponseCompatible<IHerdCredential | null>>;

package/dist/helpers/herd_credentials.js

@@ -0,0 +1,85 @@
+import { IWebResponse } from "../types/requests";
+export async function get_herd_credentials_by_herd_id(client, herd_id, args) {
+    let query = client
+        .from("herd_credentials")
+        .select("*")
+        .eq("herd_id", herd_id);
+    if (args?.type)
+        query = query.eq("type", args.type);
+    const { data, error } = await query.order("created_at", { ascending: false });
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    return IWebResponse.success(data ?? []).to_compatible();
+}
+export async function get_herd_credential_by_id(client, credential_id) {
+    const { data, error } = await client
+        .from("herd_credentials")
+        .select("*")
+        .eq("id", credential_id)
+        .single();
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error("Herd credential not found").to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function create_herd_credential(client, row) {
+    if (!row.herd_id) {
+        return IWebResponse.error("herd_id is required").to_compatible();
+    }
+    if (!row.issuer?.trim()) {
+        return IWebResponse.error("issuer is required").to_compatible();
+    }
+    if (!row.type?.trim()) {
+        return IWebResponse.error("type is required").to_compatible();
+    }
+    const { data, error } = await client
+        .from("herd_credentials")
+        .insert([row])
+        .select("*")
+        .single();
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error("Failed to create herd credential").to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function update_herd_credential(client, credential_id, patch) {
+    const { id: _id, herd_id: _hid, created_at: _ca, ...updateData } = patch;
+    if (Object.keys(updateData).length === 0) {
+        return IWebResponse.error("No valid fields to update").to_compatible();
+    }
+    const { data, error } = await client
+        .from("herd_credentials")
+        .update(updateData)
+        .eq("id", credential_id)
+        .select("*")
+        .single();
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error("Herd credential not found").to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function delete_herd_credential(client, credential_id) {
+    const { data, error } = await client
+        .from("herd_credentials")
+        .delete()
+        .eq("id", credential_id)
+        .select("*")
+        .single();
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error("Herd credential not found").to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}

package/dist/helpers/herds.js

@@ -1,7 +1,18 @@
 "use server";
+import { createHash } from "crypto";
 import { newServerClient } from "../supabase/server";
 import { EnumWebResponse, IWebResponse, } from "../types/requests";
-import { HerdModule, } from "../types/herd_module";
+import { LABELS } from "../constants/annotator";
+import { get_devices_by_herd } from "./devices";
+import { server_get_plans_by_herd_ids } from "./plans";
+import { server_get_layers_by_herd_ids } from "./layers";
+import { server_get_providers_by_herd_ids } from "./providers";
+import { server_get_users_with_herd_access_batch } from "./users";
+import { get_parts_by_herd_ids } from "./parts";
+import { server_get_more_zones_and_actions_for_herd } from "./zones";
+import { server_list_api_keys_batch } from "../api_keys/actions";
+import { server_get_session_summaries_by_herd } from "./session_summaries";
+import { server_get_session_usage_over_time_by_herd } from "./sessions";
 export async function get_herds(client) {
     const { data: herds } = await client.from("herds").select();
     if (!herds) {
@@ -45,7 +56,7 @@ export async function get_herd_by_slug(slug) {
 }
 export async function deleteHerd(herd_id) {
     const supabase = await newServerClient();
-    const { error } = await supabase.from("herds").delete().match({ id: 20 });
+    const { error } = await supabase.from("herds").delete().match({ id: herd_id });
     if (error) {
         return {
             status: EnumWebResponse.ERROR,
@@ -71,12 +82,17 @@ export async function createHerd(newHerd) {
         return IWebResponse.success(true).to_compatible();
     }
 }
+// Stable hash of modules (queries return rows in a deterministic DB order), minus
+// the per-fetch timestamp, so the client can skip no-op updates without a deep walk.
+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 server_load_herd_modules() {
     const startTime = Date.now();
-    const client_supabase = await newServerClient();
-    const herdsResult = await get_herds_with_location(client_supabase);
-    if (herdsResult.status !== EnumWebResponse.SUCCESS ||
-        !herdsResult.data) {
+    const client = await newServerClient();
+    const herdsResult = await get_herds_with_location(client);
+    if (herdsResult.status !== EnumWebResponse.SUCCESS || !herdsResult.data) {
         return {
             status: EnumWebResponse.ERROR,
             msg: herdsResult.msg ?? "Failed to load herds",
@@ -84,26 +100,88 @@ export async function server_load_herd_modules() {
             time_finished: Date.now(),
             time_sent: Date.now(),
             server_processing_time_ms: Date.now() - startTime,
+            content_hash: "",
         };
     }
     const herds = herdsResult.data.filter((h) => h.id != null);
-    const endTime = Date.now();
-    const totalLoadTime = endTime - startTime;
     if (herds.length === 0) {
-        console.log(`[server_load_herd_modules] No accessible herds (${totalLoadTime}ms)`);
+        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: totalLoadTime,
+            server_processing_time_ms: endTime - startTime,
+            content_hash: hashHerdModules([]),
         };
     }
-    const herdModulePromises = herds.map((herd) => HerdModule.from_herd(herd, client_supabase));
-    const new_herd_modules = await Promise.all(herdModulePromises);
-    const serialized_herd_modules = new_herd_modules.map((herd_module) => herd_module.to_serializable());
-    console.log(`[server_load_herd_modules] Loaded ${herds.length} herds in ${totalLoadTime}ms (parallel processing)`);
+    const herdIds = herds.map((h) => h.id);
+    // Run a per-herd RPC across all herds in parallel, tolerating individual failures.
+    const perHerd = (fn) => Promise.all(herds.map((h) => fn(h.id).catch(() => ({
+        status: EnumWebResponse.ERROR,
+        msg: "",
+        data: null,
+    }))));
+    const grouped = (p) => p.then((r) => r.data ?? {}).catch(() => ({}));
+    const [plansByHerd, layersByHerd, providersByHerd, usersByHerd, partsByDevice, devicesResults, zonesResults, summariesResults, usageResults,] = await Promise.all([
+        grouped(server_get_plans_by_herd_ids(herdIds, client)),
+        grouped(server_get_layers_by_herd_ids(herdIds, client)),
+        grouped(server_get_providers_by_herd_ids(herdIds, client)),
+        server_get_users_with_herd_access_batch(herdIds, client)
+            .then((r) => (r.status === EnumWebResponse.SUCCESS ? r.data : null))
+            .catch(() => null),
+        grouped(get_parts_by_herd_ids(client, herdIds)),
+        perHerd((id) => get_devices_by_herd(id, client)),
+        perHerd((id) => server_get_more_zones_and_actions_for_herd(id, 0, 10, client)),
+        perHerd((id) => server_get_session_summaries_by_herd(id, client)),
+        perHerd((id) => server_get_session_usage_over_time_by_herd(id, client)),
+    ]);
+    const devicesByHerdIndex = devicesResults.map((res) => res.status === EnumWebResponse.SUCCESS && res.data ? res.data : []);
+    const allDevices = devicesByHerdIndex.flat();
+    const allDeviceIds = allDevices.map((device) => device.id ?? 0);
+    let apiKeysByDevice = {};
+    if (allDeviceIds.length > 0) {
+        try {
+            apiKeysByDevice = await server_list_api_keys_batch(allDeviceIds, client);
+        }
+        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) => {
+        const zonesRes = zonesResults[index];
+        const summariesRes = summariesResults[index];
+        const usageRes = usageResults[index];
+        return {
+            herd,
+            devices: devicesByHerdIndex[index],
+            timestamp_last_refreshed: Date.now(),
+            user_roles: usersByHerd ? usersByHerd[herd.id] ?? [] : null,
+            labels: LABELS,
+            plans: plansByHerd[herd.id] ?? [],
+            zones: zonesRes.status === EnumWebResponse.SUCCESS && zonesRes.data
+                ? zonesRes.data
+                : [],
+            layers: layersByHerd[herd.id] ?? [],
+            providers: providersByHerd[herd.id] ?? [],
+            session_summaries: summariesRes.status === EnumWebResponse.SUCCESS && summariesRes.data
+                ? summariesRes.data
+                : null,
+            session_usage: usageRes.status === EnumWebResponse.SUCCESS && usageRes.data
+                ? usageRes.data
+                : null,
+        };
+    });
+    const endTime = Date.now();
+    const totalLoadTime = endTime - startTime;
+    console.log(`[server_load_herd_modules] Loaded ${herds.length} herds in ${totalLoadTime}ms (batched queries)`);
     return {
         status: EnumWebResponse.SUCCESS,
         msg: "Herd modules loaded successfully",
@@ -111,5 +189,6 @@ export async function server_load_herd_modules() {
         time_finished: endTime,
         time_sent: endTime,
         server_processing_time_ms: totalLoadTime,
+        content_hash: hashHerdModules(serialized_herd_modules),
     };
 }

package/dist/helpers/index.d.ts

@@ -3,7 +3,8 @@ export * from "./auth";
 export * from "./bounding_boxes";
 export * from "./chat";
 export * from "./certificates";
-export * from "./credentials";
+export * from "./user_credentials";
+export * from "./herd_credentials";
 export * from "./db";
 export * from "./devices";
 export * from "./email";

package/dist/helpers/index.js

@@ -3,7 +3,8 @@ export * from "./auth";
 export * from "./bounding_boxes";
 export * from "./chat";
 export * from "./certificates";
-export * from "./credentials";
+export * from "./user_credentials";
+export * from "./herd_credentials";
 export * from "./db";
 export * from "./devices";
 export * from "./email";

package/dist/helpers/layers.d.ts

@@ -1,3 +1,6 @@
+import { Database } from "../types/supabase";
 import { ILayer } from "../types/db";
 import { IWebResponseCompatible } from "../types/requests";
+import { SupabaseClient } from "@supabase/supabase-js";
 export declare function server_get_layers_by_herd(herd_id: number): Promise<IWebResponseCompatible<ILayer[]>>;
+export declare function server_get_layers_by_herd_ids(herd_ids: number[], client: SupabaseClient<Database>): Promise<IWebResponseCompatible<Record<number, ILayer[]>>>;

package/dist/helpers/layers.js

@@ -19,3 +19,23 @@ export async function server_get_layers_by_herd(herd_id) {
         return IWebResponse.success(data).to_compatible();
     }
 }
+// Fetches layers for many herds in one query, grouped by herd_id.
+export async function server_get_layers_by_herd_ids(herd_ids, client) {
+    var _a;
+    if (herd_ids.length === 0) {
+        return IWebResponse.success({}).to_compatible();
+    }
+    const { data, error } = await client
+        .from("layers")
+        .select("*")
+        .in("herd_id", herd_ids)
+        .order("id", { ascending: true });
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    const grouped = {};
+    for (const row of data ?? []) {
+        (grouped[_a = row.herd_id] ?? (grouped[_a] = [])).push(row);
+    }
+    return IWebResponse.success(grouped).to_compatible();
+}

package/dist/helpers/parts.d.ts

@@ -75,6 +75,13 @@ export declare function get_parts_by_certificate_id(client: SupabaseClient<Datab
  * @param herd_id - ID of the herd to get parts for
  */
 export declare function get_parts_by_herd_id(client: SupabaseClient<Database>, herd_id: number): Promise<IWebResponseCompatible<IPart[]>>;
+/**
+ * Retrieves active parts for all devices across many herds in one query,
+ * grouped by device_id.
+ * @param client - Supabase client instance
+ * @param herd_ids - IDs of the herds to get parts for
+ */
+export declare function get_parts_by_herd_ids(client: SupabaseClient<Database>, herd_ids: number[]): Promise<IWebResponseCompatible<Record<number, IPart[]>>>;
 /**
  * Restores a deleted part to active lifecycle
  * @param client - Supabase client instance

package/dist/helpers/parts.js

@@ -238,6 +238,38 @@ export async function get_parts_by_herd_id(client, herd_id) {
     }
     return IWebResponse.success(data).to_compatible();
 }
+/**
+ * Retrieves active parts for all devices across many herds in one query,
+ * grouped by device_id.
+ * @param client - Supabase client instance
+ * @param herd_ids - IDs of the herds to get parts for
+ */
+export async function get_parts_by_herd_ids(client, herd_ids) {
+    var _a;
+    if (herd_ids.length === 0) {
+        return IWebResponse.success({}).to_compatible();
+    }
+    const { data, error } = await client
+        .from("parts")
+        .select(`
+      *,
+      devices!parts_device_id_fkey(herd_id)
+    `)
+        .in("devices.herd_id", herd_ids)
+        .eq("lifecycle", "active")
+        .order("created_at", { ascending: false })
+        .order("id", { ascending: true });
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    const grouped = {};
+    for (const row of data ?? []) {
+        if (row.device_id == null)
+            continue;
+        (grouped[_a = row.device_id] ?? (grouped[_a] = [])).push(row);
+    }
+    return IWebResponse.success(grouped).to_compatible();
+}
 /**
  * Restores a deleted part to active lifecycle
  * @param client - Supabase client instance

package/dist/helpers/plans.d.ts

@@ -1,5 +1,8 @@
+import { Database } from "../types/supabase";
 import { IPlan } from "../types/db";
 import { IWebResponseCompatible } from "../types/requests";
+import { SupabaseClient } from "@supabase/supabase-js";
 export declare function server_get_plans_by_herd(herd_id: number): Promise<IWebResponseCompatible<IPlan[]>>;
+export declare function server_get_plans_by_herd_ids(herd_ids: number[], client: SupabaseClient<Database>): Promise<IWebResponseCompatible<Record<number, IPlan[]>>>;
 export declare function server_create_plans(plans: IPlan[]): Promise<IWebResponseCompatible<IPlan[]>>;
 export declare function server_delete_plans_by_ids(plan_ids: number[]): Promise<IWebResponseCompatible<boolean>>;

package/dist/helpers/plans.js

@@ -19,6 +19,26 @@ export async function server_get_plans_by_herd(herd_id) {
         return IWebResponse.success(data).to_compatible();
     }
 }
+// Fetches plans for many herds in one query, grouped by herd_id.
+export async function server_get_plans_by_herd_ids(herd_ids, client) {
+    var _a;
+    if (herd_ids.length === 0) {
+        return IWebResponse.success({}).to_compatible();
+    }
+    const { data, error } = await client
+        .from("plans")
+        .select("*")
+        .in("herd_id", herd_ids)
+        .order("id", { ascending: true });
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    const grouped = {};
+    for (const row of data ?? []) {
+        (grouped[_a = row.herd_id] ?? (grouped[_a] = [])).push(row);
+    }
+    return IWebResponse.success(grouped).to_compatible();
+}
 // function that uploads plan to our db
 export async function server_create_plans(plans) {
     // loop through plans and format

package/dist/helpers/providers.d.ts

@@ -1,6 +1,9 @@
+import { Database } from "../types/supabase";
 import { IProvider } from "../types/db";
 import { IWebResponseCompatible } from "../types/requests";
+import { SupabaseClient } from "@supabase/supabase-js";
 export declare function server_get_providers_by_herd(herd_id: number): Promise<IWebResponseCompatible<IProvider[]>>;
+export declare function server_get_providers_by_herd_ids(herd_ids: number[], client: SupabaseClient<Database>): Promise<IWebResponseCompatible<Record<number, IProvider[]>>>;
 export declare function server_create_provider(provider: Omit<IProvider, "id" | "created_at">): Promise<IWebResponseCompatible<IProvider>>;
 export declare function server_update_provider(provider_id: number, updates: Partial<Omit<IProvider, "id" | "created_at">>): Promise<IWebResponseCompatible<IProvider>>;
 export declare function server_delete_providers_by_ids(provider_ids: number[]): Promise<IWebResponseCompatible<boolean>>;

package/dist/helpers/providers.js

@@ -19,6 +19,26 @@ export async function server_get_providers_by_herd(herd_id) {
         return IWebResponse.success(data).to_compatible();
     }
 }
+// Fetches providers for many herds in one query, grouped by herd_id.
+export async function server_get_providers_by_herd_ids(herd_ids, client) {
+    var _a;
+    if (herd_ids.length === 0) {
+        return IWebResponse.success({}).to_compatible();
+    }
+    const { data, error } = await client
+        .from("providers")
+        .select("*")
+        .in("herd_id", herd_ids)
+        .order("id", { ascending: true });
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    const grouped = {};
+    for (const row of data ?? []) {
+        (grouped[_a = row.herd_id] ?? (grouped[_a] = [])).push(row);
+    }
+    return IWebResponse.success(grouped).to_compatible();
+}
 // function that creates a new provider in our db
 export async function server_create_provider(provider) {
     const supabase = await newServerClient();

package/dist/helpers/user_credentials.d.ts

@@ -0,0 +1,9 @@
+import { Database } from "../types/supabase";
+import { CredentialQueryArgs, IUserCredential, UserCredentialInsert, UserCredentialUpdate } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+import { SupabaseClient } from "@supabase/supabase-js";
+export declare function get_user_credentials_by_user_id(client: SupabaseClient<Database>, user_id: string, args?: CredentialQueryArgs): Promise<IWebResponseCompatible<IUserCredential[]>>;
+export declare function get_user_credential_by_id(client: SupabaseClient<Database>, credential_id: number): Promise<IWebResponseCompatible<IUserCredential | null>>;
+export declare function create_user_credential(client: SupabaseClient<Database>, row: UserCredentialInsert): Promise<IWebResponseCompatible<IUserCredential | null>>;
+export declare function update_user_credential(client: SupabaseClient<Database>, credential_id: number, patch: UserCredentialUpdate): Promise<IWebResponseCompatible<IUserCredential | null>>;
+export declare function delete_user_credential(client: SupabaseClient<Database>, credential_id: number): Promise<IWebResponseCompatible<IUserCredential | null>>;

package/dist/helpers/user_credentials.js

@@ -0,0 +1,85 @@
+import { IWebResponse } from "../types/requests";
+export async function get_user_credentials_by_user_id(client, user_id, args) {
+    let query = client
+        .from("user_credentials")
+        .select("*")
+        .eq("user_id", user_id);
+    if (args?.type)
+        query = query.eq("type", args.type);
+    const { data, error } = await query.order("created_at", { ascending: false });
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    return IWebResponse.success(data ?? []).to_compatible();
+}
+export async function get_user_credential_by_id(client, credential_id) {
+    const { data, error } = await client
+        .from("user_credentials")
+        .select("*")
+        .eq("id", credential_id)
+        .single();
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error("User credential not found").to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function create_user_credential(client, row) {
+    if (!row.user_id) {
+        return IWebResponse.error("user_id is required").to_compatible();
+    }
+    if (!row.issuer?.trim()) {
+        return IWebResponse.error("issuer is required").to_compatible();
+    }
+    if (!row.type?.trim()) {
+        return IWebResponse.error("type is required").to_compatible();
+    }
+    const { data, error } = await client
+        .from("user_credentials")
+        .insert([row])
+        .select("*")
+        .single();
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error("Failed to create user credential").to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function update_user_credential(client, credential_id, patch) {
+    const { id: _id, user_id: _uid, created_at: _ca, ...updateData } = patch;
+    if (Object.keys(updateData).length === 0) {
+        return IWebResponse.error("No valid fields to update").to_compatible();
+    }
+    const { data, error } = await client
+        .from("user_credentials")
+        .update(updateData)
+        .eq("id", credential_id)
+        .select("*")
+        .single();
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error("User credential not found").to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function delete_user_credential(client, credential_id) {
+    const { data, error } = await client
+        .from("user_credentials")
+        .delete()
+        .eq("id", credential_id)
+        .select("*")
+        .single();
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error("User credential not found").to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}

package/dist/helpers/users.d.ts

@@ -5,6 +5,7 @@ import { Database } from "../types/supabase";
 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, supabaseClient?: SupabaseClient): Promise<IWebResponseCompatible<IUserAndRole[]>>;
+export declare function server_get_users_with_herd_access_batch(herd_ids: number[], client: SupabaseClient): Promise<IWebResponseCompatible<Record<number, IUserAndRole[]>>>;
 export declare function server_upsert_user_herd_role(herd_id: number, username: string, herd_role_id: number): Promise<IWebResponseCompatible<IUserAndRole | null>>;
 export type UserProfileUpdate = Database["public"]["Tables"]["users"]["Update"];
 export declare function update_user_profile(client: SupabaseClient<Database>, user_id: string, patch: UserProfileUpdate): Promise<IWebResponseCompatible<IUserProfileRow | null>>;

package/dist/helpers/users.js

@@ -49,6 +49,36 @@ export async function server_get_users_with_herd_access(herd_id, supabaseClient)
     }));
     return IWebResponse.success(transformedData).to_compatible();
 }
+// Fetches users-with-role for many herds in one query, grouped by herd_id.
+export async function server_get_users_with_herd_access_batch(herd_ids, client) {
+    var _a;
+    if (herd_ids.length === 0) {
+        return IWebResponse.success({}).to_compatible();
+    }
+    const { data, error } = await client
+        .from("users_roles_per_herd")
+        .select(`
+      herd_id,
+      herd_role_id,
+      herd_roles (*),
+      users!users_roles_per_herd_user_id_fkey (*)
+    `)
+        .in("herd_id", herd_ids)
+        .order("herd_id", { ascending: true })
+        .order("user_id", { ascending: true });
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    const grouped = {};
+    for (const item of (data ?? [])) {
+        (grouped[_a = item.herd_id] ?? (grouped[_a] = [])).push({
+            user: item.users,
+            herd_role_id: item.herd_role_id,
+            herd_role: item.herd_roles,
+        });
+    }
+    return IWebResponse.success(grouped).to_compatible();
+}
 export async function server_upsert_user_herd_role(herd_id, username, herd_role_id) {
     const supabase = await newServerClient();
     const { data: user, error: user_error } = await supabase

package/dist/helpers/zones.d.ts

@@ -1,5 +1,6 @@
 import { IZoneWithActions } from "../types/db";
 import { IWebResponseCompatible } from "../types/requests";
+import { SupabaseClient } from "@supabase/supabase-js";
 /**
  * Get more zones and actions for a herd
  * @param herd_id - The ID of the herd to get zones and actions for
@@ -8,7 +9,7 @@ import { IWebResponseCompatible } from "../types/requests";
  * @returns A list of zones and actions
  * @throws An error if the zones or actions are not fetched
  */
-export declare function server_get_more_zones_and_actions_for_herd(herd_id: number, offset: number, page_count?: number): Promise<IWebResponseCompatible<IZoneWithActions[]>>;
+export declare function server_get_more_zones_and_actions_for_herd(herd_id: number, offset: number, page_count?: number, client?: SupabaseClient): Promise<IWebResponseCompatible<IZoneWithActions[]>>;
 /**
  * Create zones and actions for a herd
  * @param zones - The zones to create

package/dist/helpers/zones.js

@@ -8,10 +8,10 @@ import { EnumWebResponse, IWebResponse, } from "../types/requests";
  * @returns A list of zones and actions
  * @throws An error if the zones or actions are not fetched
  */
-export async function server_get_more_zones_and_actions_for_herd(herd_id, offset, page_count = 10) {
+export async function server_get_more_zones_and_actions_for_herd(herd_id, offset, page_count = 10, client) {
     const from = offset * page_count;
     const to = from + page_count - 1;
-    const supabase = await newServerClient();
+    const supabase = client || (await newServerClient());
     // make rpc call to get_events_with_tags_for_herd(herd_id, offset, limit)
     const { data, error } = await supabase.rpc("get_zones_and_actions_for_herd", {
         herd_id_caller: herd_id,

package/dist/hooks/useDeviceDisplayName.d.ts

@@ -0,0 +1,8 @@
+import type { SupabaseClient } from "@supabase/supabase-js";
+import type { IDevice } from "../types/db";
+import type { IHerdModule } from "../types/herd_module";
+export declare function primeDeviceDisplayNameCache(devices: Iterable<IDevice>): void;
+export declare function useDeviceDisplayName(deviceId: number | null | undefined, options?: {
+    herdModules?: IHerdModule[];
+    supabase?: SupabaseClient;
+}): string | null;