@adventurelabs/scout-core 1.4.84 → 1.4.86

package/dist/helpers/localizations.js

@@ -0,0 +1,51 @@
+"use server";
+import { newServerClient } from "../supabase/server";
+import { EnumWebResponse, IWebResponse, } from "../types/requests";
+export async function server_get_localizations() {
+    const supabase = await newServerClient();
+    const { data, error } = await supabase
+        .from("localizations")
+        .select("*")
+        .order("region");
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
+    }
+    return IWebResponse.success(data ?? []).to_compatible();
+}
+export async function server_get_localization_by_id(localization_id) {
+    const supabase = await newServerClient();
+    const { data, error } = await supabase
+        .from("localizations")
+        .select("*")
+        .eq("id", localization_id)
+        .maybeSingle();
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function server_create_localization(row) {
+    const supabase = await newServerClient();
+    const { data, error } = await supabase
+        .from("localizations")
+        .insert(row)
+        .select("*")
+        .single();
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function server_update_localization(localization_id, updates) {
+    const supabase = await newServerClient();
+    const { data, error } = await supabase
+        .from("localizations")
+        .update(updates)
+        .eq("id", localization_id)
+        .select("*")
+        .single();
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    return IWebResponse.success(data).to_compatible();
+}

package/dist/helpers/maintenance_requests.d.ts

@@ -0,0 +1,15 @@
+import { Database } from "../types/supabase";
+import { IMaintenanceRequest, MaintenanceRequestInsert, MaintenanceRequestUpdate } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+import { SupabaseClient } from "@supabase/supabase-js";
+export declare function get_maintenance_requests_by_device_id(client: SupabaseClient<Database>, device_id: number): Promise<IWebResponseCompatible<IMaintenanceRequest[]>>;
+export declare function get_maintenance_requests_by_part_id(client: SupabaseClient<Database>, part_id: number): Promise<IWebResponseCompatible<IMaintenanceRequest[]>>;
+export declare function get_maintenance_requests_by_herd_id(client: SupabaseClient<Database>, herd_id: number, options?: {
+    limit?: number;
+    offset?: number;
+}): Promise<IWebResponseCompatible<IMaintenanceRequest[]>>;
+export declare function get_maintenance_requests_count_by_herd_id(client: SupabaseClient<Database>, herd_id: number): Promise<IWebResponseCompatible<number>>;
+export declare function get_maintenance_request_by_id(client: SupabaseClient<Database>, request_id: number): Promise<IWebResponseCompatible<IMaintenanceRequest | null>>;
+export declare function create_maintenance_request(client: SupabaseClient<Database>, row: MaintenanceRequestInsert): Promise<IWebResponseCompatible<IMaintenanceRequest | null>>;
+export declare function update_maintenance_request(client: SupabaseClient<Database>, request_id: number, patch: MaintenanceRequestUpdate): Promise<IWebResponseCompatible<IMaintenanceRequest | null>>;
+export declare function delete_maintenance_request(client: SupabaseClient<Database>, request_id: number): Promise<IWebResponseCompatible<IMaintenanceRequest | null>>;

package/dist/helpers/maintenance_requests.js

@@ -0,0 +1,128 @@
+import { IWebResponse } from "../types/requests";
+function assert_maintenance_request_insert(row) {
+    if (!row.description?.trim()) {
+        return IWebResponse.error("description is required").to_compatible();
+    }
+    if (!row.defect_timestamp) {
+        return IWebResponse.error("defect_timestamp is required").to_compatible();
+    }
+    const targets = [row.device_id, row.part_id];
+    const target_count = targets.filter((target) => target != null).length;
+    if (target_count !== 1) {
+        return IWebResponse.error("exactly one of device_id or part_id is required").to_compatible();
+    }
+    return null;
+}
+export async function get_maintenance_requests_by_device_id(client, device_id) {
+    const { data, error } = await client
+        .from("maintenance_requests")
+        .select("*")
+        .eq("device_id", device_id)
+        .order("created_at", { ascending: false });
+    if (error) {
+        return IWebResponse.error(error.message)
+            .to_compatible();
+    }
+    return IWebResponse.success(data ?? []).to_compatible();
+}
+export async function get_maintenance_requests_by_part_id(client, part_id) {
+    const { data, error } = await client
+        .from("maintenance_requests")
+        .select("*")
+        .eq("part_id", part_id)
+        .order("created_at", { ascending: false });
+    if (error) {
+        return IWebResponse.error(error.message)
+            .to_compatible();
+    }
+    return IWebResponse.success(data ?? []).to_compatible();
+}
+export async function get_maintenance_requests_by_herd_id(client, herd_id, options) {
+    const { data, error } = await client.rpc("get_maintenance_requests_for_herd", {
+        herd_id_caller: herd_id,
+        limit_caller: options?.limit ?? 50,
+        offset_caller: options?.offset ?? 0,
+    });
+    if (error) {
+        return IWebResponse.error(error.message)
+            .to_compatible();
+    }
+    return IWebResponse.success(data ?? []).to_compatible();
+}
+export async function get_maintenance_requests_count_by_herd_id(client, herd_id) {
+    const { data, error } = await client.rpc("get_total_maintenance_requests_for_herd", { herd_id_caller: herd_id });
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    return IWebResponse.success(data ?? 0).to_compatible();
+}
+export async function get_maintenance_request_by_id(client, request_id) {
+    const { data, error } = await client
+        .from("maintenance_requests")
+        .select("*")
+        .eq("id", request_id)
+        .maybeSingle();
+    if (error) {
+        return IWebResponse.error(error.message)
+            .to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error("Maintenance request not found").to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function create_maintenance_request(client, row) {
+    const invalid = assert_maintenance_request_insert(row);
+    if (invalid) {
+        return invalid;
+    }
+    const { data, error } = await client
+        .from("maintenance_requests")
+        .insert([row])
+        .select("*")
+        .single();
+    if (error) {
+        return IWebResponse.error(error.message)
+            .to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error("Failed to create maintenance request").to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function update_maintenance_request(client, request_id, patch) {
+    const { id: _id, 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("maintenance_requests")
+        .update(updateData)
+        .eq("id", request_id)
+        .select("*")
+        .single();
+    if (error) {
+        return IWebResponse.error(error.message)
+            .to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error("Maintenance request not found").to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function delete_maintenance_request(client, request_id) {
+    const { data, error } = await client
+        .from("maintenance_requests")
+        .delete()
+        .eq("id", request_id)
+        .select("*")
+        .single();
+    if (error) {
+        return IWebResponse.error(error.message)
+            .to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error("Maintenance request not found").to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}

package/dist/helpers/manufacturers.d.ts

@@ -0,0 +1,8 @@
+import { IManufacturer, ManufacturerInsert, ManufacturerUpdate } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+export declare function server_get_manufacturers(options?: {
+    include_inactive?: boolean;
+}): Promise<IWebResponseCompatible<IManufacturer[]>>;
+export declare function server_get_manufacturer_by_id(manufacturer_id: number): Promise<IWebResponseCompatible<IManufacturer | null>>;
+export declare function server_create_manufacturer(row: ManufacturerInsert): Promise<IWebResponseCompatible<IManufacturer | null>>;
+export declare function server_update_manufacturer(manufacturer_id: number, updates: ManufacturerUpdate): Promise<IWebResponseCompatible<IManufacturer | null>>;

package/dist/helpers/manufacturers.js

@@ -0,0 +1,52 @@
+"use server";
+import { newServerClient } from "../supabase/server";
+import { EnumWebResponse, IWebResponse, } from "../types/requests";
+export async function server_get_manufacturers(options) {
+    const supabase = await newServerClient();
+    let query = supabase.from("manufacturers").select("*").order("name");
+    if (!options?.include_inactive) {
+        query = query.eq("lifecycle", "active");
+    }
+    const { data, error } = await query;
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
+    }
+    return IWebResponse.success(data ?? []).to_compatible();
+}
+export async function server_get_manufacturer_by_id(manufacturer_id) {
+    const supabase = await newServerClient();
+    const { data, error } = await supabase
+        .from("manufacturers")
+        .select("*")
+        .eq("id", manufacturer_id)
+        .maybeSingle();
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function server_create_manufacturer(row) {
+    const supabase = await newServerClient();
+    const { data, error } = await supabase
+        .from("manufacturers")
+        .insert(row)
+        .select("*")
+        .single();
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function server_update_manufacturer(manufacturer_id, updates) {
+    const supabase = await newServerClient();
+    const { data, error } = await supabase
+        .from("manufacturers")
+        .update(updates)
+        .eq("id", manufacturer_id)
+        .select("*")
+        .single();
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    return IWebResponse.success(data).to_compatible();
+}

package/dist/helpers/parts.d.ts

@@ -1,5 +1,5 @@
 import { Database } from "../types/supabase";
-import { EntityLifecycle, IPart, PartInsert } from "../types/db";
+import { EntityLifecycle, IPart, IPartWithProduct, PartInsert } from "../types/db";
 import { IWebResponseCompatible } from "../types/requests";
 import { SupabaseClient } from "@supabase/supabase-js";
 import { LifecycleUpdateOptions } from "./lifecycle";
@@ -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, IPartWithProduct[]>>>;
 /**
  * Restores a deleted part to active lifecycle
  * @param client - Supabase client instance

package/dist/helpers/parts.js

@@ -238,6 +238,44 @@ 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),
+      product_numbers!parts_product_number_fkey(products(*))
+    `)
+        .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;
+        const { product_numbers, devices: _devices, ...partRow } = row;
+        const part = {
+            ...partRow,
+            product: product_numbers?.products ?? null,
+        };
+        (grouped[_a = row.device_id] ?? (grouped[_a] = [])).push(part);
+    }
+    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/product_numbers.d.ts

@@ -0,0 +1,7 @@
+import { IProduct, IProductNumber, ProductNumberInsert, ProductNumberUpdate } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+export declare function server_get_product_numbers_by_product(product_id: number): Promise<IWebResponseCompatible<IProductNumber[]>>;
+export declare function server_get_product_number(product_number: string): Promise<IWebResponseCompatible<IProductNumber | null>>;
+export declare function server_get_product_for_product_number(product_number: string): Promise<IWebResponseCompatible<IProduct | null>>;
+export declare function server_create_product_number(row: ProductNumberInsert): Promise<IWebResponseCompatible<IProductNumber | null>>;
+export declare function server_update_product_number(product_number: string, updates: ProductNumberUpdate): Promise<IWebResponseCompatible<IProductNumber | null>>;

package/dist/helpers/product_numbers.js

@@ -0,0 +1,66 @@
+"use server";
+import { newServerClient } from "../supabase/server";
+import { EnumWebResponse, IWebResponse, } from "../types/requests";
+export async function server_get_product_numbers_by_product(product_id) {
+    const supabase = await newServerClient();
+    const { data, error } = await supabase
+        .from("product_numbers")
+        .select("*")
+        .eq("product_id", product_id)
+        .order("product_number");
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
+    }
+    return IWebResponse.success(data ?? []).to_compatible();
+}
+export async function server_get_product_number(product_number) {
+    const supabase = await newServerClient();
+    const { data, error } = await supabase
+        .from("product_numbers")
+        .select("*")
+        .eq("product_number", product_number)
+        .maybeSingle();
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+// Resolves the product line for a given product_number via the FK chain.
+export async function server_get_product_for_product_number(product_number) {
+    const supabase = await newServerClient();
+    const { data, error } = await supabase
+        .from("product_numbers")
+        .select("products(*)")
+        .eq("product_number", product_number)
+        .maybeSingle();
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    const product = data?.products ?? null;
+    return IWebResponse.success(product).to_compatible();
+}
+export async function server_create_product_number(row) {
+    const supabase = await newServerClient();
+    const { data, error } = await supabase
+        .from("product_numbers")
+        .insert(row)
+        .select("*")
+        .single();
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function server_update_product_number(product_number, updates) {
+    const supabase = await newServerClient();
+    const { data, error } = await supabase
+        .from("product_numbers")
+        .update(updates)
+        .eq("product_number", product_number)
+        .select("*")
+        .single();
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    return IWebResponse.success(data).to_compatible();
+}

package/dist/helpers/products.d.ts

@@ -0,0 +1,9 @@
+import { IProduct, ProductInsert, ProductUpdate } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+export declare function server_get_products(options?: {
+    include_inactive?: boolean;
+}): Promise<IWebResponseCompatible<IProduct[]>>;
+export declare function server_get_product_by_id(product_id: number): Promise<IWebResponseCompatible<IProduct | null>>;
+export declare function server_get_products_by_manufacturer(manufacturer_id: number): Promise<IWebResponseCompatible<IProduct[]>>;
+export declare function server_create_product(row: ProductInsert): Promise<IWebResponseCompatible<IProduct | null>>;
+export declare function server_update_product(product_id: number, updates: ProductUpdate): Promise<IWebResponseCompatible<IProduct | null>>;

package/dist/helpers/products.js

@@ -0,0 +1,65 @@
+"use server";
+import { newServerClient } from "../supabase/server";
+import { EnumWebResponse, IWebResponse, } from "../types/requests";
+export async function server_get_products(options) {
+    const supabase = await newServerClient();
+    let query = supabase.from("products").select("*").order("name");
+    if (!options?.include_inactive) {
+        query = query.eq("lifecycle", "active");
+    }
+    const { data, error } = await query;
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
+    }
+    return IWebResponse.success(data ?? []).to_compatible();
+}
+export async function server_get_product_by_id(product_id) {
+    const supabase = await newServerClient();
+    const { data, error } = await supabase
+        .from("products")
+        .select("*")
+        .eq("id", product_id)
+        .maybeSingle();
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function server_get_products_by_manufacturer(manufacturer_id) {
+    const supabase = await newServerClient();
+    const { data, error } = await supabase
+        .from("products")
+        .select("*")
+        .eq("manufacturer_id", manufacturer_id)
+        .eq("lifecycle", "active")
+        .order("name");
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
+    }
+    return IWebResponse.success(data ?? []).to_compatible();
+}
+export async function server_create_product(row) {
+    const supabase = await newServerClient();
+    const { data, error } = await supabase
+        .from("products")
+        .insert(row)
+        .select("*")
+        .single();
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function server_update_product(product_id, updates) {
+    const supabase = await newServerClient();
+    const { data, error } = await supabase
+        .from("products")
+        .update(updates)
+        .eq("id", product_id)
+        .select("*")
+        .single();
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    return IWebResponse.success(data).to_compatible();
+}

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/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,