@adventurelabs/scout-core 1.5.4 → 2.0.0

package/dist/helpers/tags.queries.js

@@ -0,0 +1,454 @@
+import { EnumWebResponse, IWebResponse, } from "../types/requests";
+import { addEventMediaUrls } from "./media_urls";
+function extractLatitude(location) {
+    try {
+        if (typeof location === "object" && location !== null) {
+            if ("coordinates" in location && Array.isArray(location.coordinates)) {
+                return location.coordinates[1];
+            }
+            if ("y" in location) {
+                return location.y;
+            }
+        }
+        if (typeof location === "string") {
+            const match = location.match(/Point\(([^)]+)\)/);
+            if (match) {
+                const coords = match[1].split(" ").map(Number);
+                if (coords.length === 2) {
+                    return coords[1];
+                }
+            }
+        }
+    }
+    catch (error) {
+        console.warn("Error extracting latitude:", error);
+    }
+    return null;
+}
+function extractLongitude(location) {
+    try {
+        if (typeof location === "object" && location !== null) {
+            if ("coordinates" in location && Array.isArray(location.coordinates)) {
+                return location.coordinates[0];
+            }
+            if ("x" in location) {
+                return location.x;
+            }
+        }
+        if (typeof location === "string") {
+            const match = location.match(/Point\(([^)]+)\)/);
+            if (match) {
+                const coords = match[1].split(" ").map(Number);
+                if (coords.length === 2) {
+                    return coords[0];
+                }
+            }
+        }
+    }
+    catch (error) {
+        console.warn("Error extracting longitude:", error);
+    }
+    return null;
+}
+function rpcModelIdsParam(model_ids) {
+    if (model_ids != null && model_ids.length > 0) {
+        return { model_ids_caller: model_ids };
+    }
+    return {};
+}
+export async function create_tags_query(client, tags) {
+    const formatted_tags = tags.map((tag) => {
+        const { id, ...rest } = tag;
+        return {
+            ...rest,
+            observation_type: rest.observation_type,
+        };
+    });
+    const { data, error } = await client
+        .from("tags")
+        .insert(formatted_tags)
+        .select("*");
+    if (error) {
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: null,
+        };
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function delete_tags_by_ids_query(client, tag_ids) {
+    const { error } = await client.from("tags").delete().in("id", tag_ids);
+    if (error) {
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: false,
+        };
+    }
+    return IWebResponse.success(true).to_compatible();
+}
+export async function update_tags_query(client, tags) {
+    const updatedTags = [];
+    for (const tag of tags) {
+        const { id, inserted_at: _ignoredInsertedAt, ...updateData } = tag;
+        const { data, error } = await client
+            .from("tags")
+            .update({
+            ...updateData,
+            observation_type: updateData.observation_type,
+        })
+            .eq("id", id)
+            .select("*")
+            .single();
+        if (error) {
+            return {
+                status: EnumWebResponse.ERROR,
+                msg: error.message,
+                data: null,
+            };
+        }
+        if (data) {
+            updatedTags.push(data);
+        }
+    }
+    return IWebResponse.success(updatedTags).to_compatible();
+}
+export async function get_more_events_with_tags_by_herd_query(client, herd_id, offset, page_count = 10) {
+    const from = offset * page_count;
+    const { data, error } = await client.rpc("get_events_and_tags_for_herd", {
+        herd_id_caller: herd_id,
+        offset_caller: from,
+        limit_caller: page_count,
+    });
+    if (error) {
+        console.warn("Error fetching events with tags by herd:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: [],
+        };
+    }
+    const filteredData = (data || []).map((event) => {
+        if (!event.tags)
+            return event;
+        event.tags = event.tags.filter((tag) => tag !== null);
+        return event;
+    });
+    return IWebResponse.success(await addEventMediaUrls(client, filteredData)).to_compatible();
+}
+export async function get_events_and_tags_for_device_query(client, device_id, limit = 3) {
+    const { data, error } = await client.rpc("get_events_and_tags_for_device", {
+        device_id_caller: device_id,
+        limit_caller: limit,
+    });
+    if (error) {
+        console.warn("Error fetching recent events with tags by device:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: [],
+        };
+    }
+    return IWebResponse.success(await addEventMediaUrls(client, data || [])).to_compatible();
+}
+export async function get_events_and_tags_for_devices_batch_query(client, device_ids, limit = 1) {
+    var _a;
+    const { data, error } = await client.rpc("get_events_and_tags_for_devices_batch", {
+        device_ids,
+        limit_per_device: limit,
+    });
+    if (error) {
+        console.error(`[Events Batch] Database error:`, error.message);
+        console.log(`[Events Batch] Falling back to individual calls...`);
+        const result = {};
+        const promises = device_ids.map(async (device_id) => {
+            try {
+                const response = await get_events_and_tags_for_device_query(client, device_id, limit);
+                if (response.status === EnumWebResponse.SUCCESS &&
+                    response.data) {
+                    result[device_id] = response.data;
+                }
+                else {
+                    result[device_id] = [];
+                }
+            }
+            catch (err) {
+                console.warn(`[Events Batch] Failed for device ${device_id}:`, err);
+                result[device_id] = [];
+            }
+        });
+        await Promise.all(promises);
+        return IWebResponse.success(result).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.success({}).to_compatible();
+    }
+    const eventsByDevice = {};
+    data.forEach((row) => {
+        const device_id = row.device_id;
+        if (!eventsByDevice[device_id]) {
+            eventsByDevice[device_id] = [];
+        }
+        eventsByDevice[device_id].push({
+            id: row.id,
+            inserted_at: row.inserted_at,
+            message: row.message,
+            media_url: row.media_url,
+            file_path: row.file_path,
+            latitude: row.latitude,
+            longitude: row.longitude,
+            altitude: row.altitude,
+            heading: row.heading,
+            media_type: row.media_type,
+            device_id,
+            timestamp_observation: row.timestamp_observation,
+            is_public: row.is_public,
+            earthranger_url: row.earthranger_url,
+            herd_id: row.herd_id,
+            tags: Array.isArray(row.tags) ? row.tags : [],
+            embedded_at: row.embedded_at ?? null,
+            segmented_at: row.segmented_at ?? null,
+            tagged_at: row.tagged_at ?? null,
+        });
+    });
+    const eventsWithUrls = await addEventMediaUrls(client, Object.values(eventsByDevice).flat());
+    const result = {};
+    for (const event of eventsWithUrls) {
+        if (event.device_id == null)
+            continue;
+        (result[_a = event.device_id] ?? (result[_a] = [])).push(event);
+    }
+    return IWebResponse.success(result).to_compatible();
+}
+export async function get_event_and_tags_by_event_id_query(client, event_id) {
+    const { data, error } = await client
+        .from("events")
+        .select(`
+      *,
+      tags: tags (*)
+    `)
+        .eq("id", event_id);
+    if (error) {
+        console.warn("Error fetching event with tags by event id:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: null,
+        };
+    }
+    if (!data || data.length === 0) {
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: "Event not found",
+            data: null,
+        };
+    }
+    const { data: deviceData, error: deviceError } = await client
+        .from("devices")
+        .select("herd_id")
+        .eq("id", data[0].device_id)
+        .single();
+    if (deviceError) {
+        console.warn("Error fetching device herd_id:", deviceError.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: deviceError.message,
+            data: null,
+        };
+    }
+    let latitude = null;
+    let longitude = null;
+    try {
+        if (data[0].location) {
+            if (typeof data[0].location === "object" && data[0].location !== null) {
+                if ("coordinates" in data[0].location &&
+                    Array.isArray(data[0].location.coordinates)) {
+                    longitude = data[0].location.coordinates[0];
+                    latitude = data[0].location.coordinates[1];
+                }
+                else if ("x" in data[0].location && "y" in data[0].location) {
+                    longitude = data[0].location.x;
+                    latitude = data[0].location.y;
+                }
+            }
+            else if (typeof data[0].location === "string") {
+                const match = data[0].location.match(/Point\(([^)]+)\)/);
+                if (match) {
+                    const coords = match[1].split(" ").map(Number);
+                    if (coords.length === 2) {
+                        longitude = coords[0];
+                        latitude = coords[1];
+                    }
+                }
+            }
+        }
+    }
+    catch (locationError) {
+        console.warn("Error parsing location data:", locationError);
+    }
+    const transformedData = {
+        id: data[0].id,
+        inserted_at: data[0].inserted_at,
+        message: data[0].message,
+        media_url: data[0].media_url,
+        latitude,
+        longitude,
+        altitude: data[0].altitude,
+        heading: data[0].heading,
+        media_type: data[0].media_type,
+        device_id: data[0].device_id,
+        timestamp_observation: data[0].timestamp_observation,
+        is_public: data[0].is_public,
+        herd_id: deviceData.herd_id,
+        tags: (data[0].tags || []).map((tag) => {
+            const originLoc = tag.origin_location;
+            const subjectLoc = tag.subject_location;
+            return {
+                id: tag.id,
+                inserted_at: tag.inserted_at,
+                artifact_id: tag.artifact_id,
+                event_id: tag.event_id,
+                model_id: tag.model_id,
+                width: tag.width,
+                height: tag.height,
+                conf: tag.conf,
+                x: tag.x,
+                y: tag.y,
+                class: tag.class,
+                timestamp_observation: tag.timestamp_observation,
+                frame_index: tag.frame_index ?? null,
+                origin_location: tag.origin_location ?? null,
+                origin_pitch: tag.origin_pitch,
+                origin_heading: tag.origin_heading,
+                origin_roll: tag.origin_roll,
+                sensor_pitch: tag.sensor_pitch,
+                sensor_yaw: tag.sensor_yaw,
+                sensor_roll: tag.sensor_roll,
+                origin_height: tag.origin_height,
+                subject_location: tag.subject_location ?? null,
+                subject_height: tag.subject_height,
+                origin_latitude: originLoc ? extractLatitude(originLoc) : null,
+                origin_longitude: originLoc ? extractLongitude(originLoc) : null,
+                subject_latitude: subjectLoc ? extractLatitude(subjectLoc) : null,
+                subject_longitude: subjectLoc ? extractLongitude(subjectLoc) : null,
+                subject_id: tag.subject_id ?? null,
+            };
+        }),
+        earthranger_url: data[0].earthranger_url,
+        file_path: data[0].file_path,
+        embedded_at: data[0].embedded_at ?? null,
+        segmented_at: data[0].segmented_at ?? null,
+        tagged_at: data[0].tagged_at ?? null,
+    };
+    const [eventWithUrl] = await addEventMediaUrls(client, [transformedData]);
+    return IWebResponse.success(eventWithUrl).to_compatible();
+}
+export async function get_tags_for_artifact_query(client, artifactId, options) {
+    const { data, error } = await client.rpc("get_tags_for_artifact", {
+        artifact_id_caller: artifactId,
+        ...(options?.start_timestamp != null && {
+            start_timestamp_caller: options.start_timestamp,
+        }),
+        ...(options?.end_timestamp != null && {
+            end_timestamp_caller: options.end_timestamp,
+        }),
+        ...rpcModelIdsParam(options?.model_ids),
+        ...(options?.max_elements != null && {
+            max_elements_caller: options.max_elements,
+        }),
+    });
+    if (error) {
+        console.warn("Error fetching tags for artifact:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: [],
+        };
+    }
+    return IWebResponse.success(data ?? []).to_compatible();
+}
+export async function get_tags_for_artifact_by_frame_index_query(client, artifactId, minConf, frameIndexStart, frameIndexEnd, model_ids = null, maxElements = null) {
+    const { data, error } = await client.rpc("get_tags_for_artifact_by_frame_index", {
+        artifact_id_caller: artifactId,
+        min_conf_caller: minConf,
+        frame_index_start_caller: frameIndexStart,
+        frame_index_end_caller: frameIndexEnd,
+        ...rpcModelIdsParam(model_ids),
+        ...(maxElements != null && { max_elements_caller: maxElements }),
+    });
+    if (error) {
+        console.warn("Error fetching tags for artifact by frame index:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: [],
+        };
+    }
+    return IWebResponse.success(data ?? []).to_compatible();
+}
+export async function get_tags_for_artifact_by_subject_id_query(client, artifactId, subjectId, model_ids = null, maxElements = null) {
+    const { data, error } = await client.rpc("get_tags_for_artifact_by_subject_id", {
+        artifact_id_caller: artifactId,
+        subject_id_caller: subjectId,
+        ...rpcModelIdsParam(model_ids),
+        ...(maxElements != null && { max_elements_caller: maxElements }),
+    });
+    if (error) {
+        console.warn("Error fetching tags for artifact by subject id:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: [],
+        };
+    }
+    return IWebResponse.success(data ?? []).to_compatible();
+}
+export async function get_minimal_subjects_for_artifact_query(client, artifactId, options) {
+    const { data, error } = await client.rpc("get_minimal_subjects_for_artifact", {
+        artifact_id_caller: artifactId,
+        ...(options?.min_avg_conf != null && {
+            min_avg_conf_caller: options.min_avg_conf,
+        }),
+        ...(options?.min_count != null && {
+            min_count_caller: options.min_count,
+        }),
+        ...rpcModelIdsParam(options?.model_ids),
+        ...(options?.max_elements != null && {
+            max_elements_caller: options.max_elements,
+        }),
+    });
+    if (error) {
+        console.warn("Error fetching minimal subjects for artifact:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: [],
+        };
+    }
+    return IWebResponse.success(data ?? []).to_compatible();
+}
+export async function get_tags_for_event_query(client, eventId, options) {
+    const { data, error } = await client.rpc("get_tags_for_event", {
+        event_id_caller: eventId,
+        ...(options?.start_timestamp != null && {
+            start_timestamp_caller: options.start_timestamp,
+        }),
+        ...(options?.end_timestamp != null && {
+            end_timestamp_caller: options.end_timestamp,
+        }),
+        ...rpcModelIdsParam(options?.model_ids),
+        ...(options?.max_elements != null && {
+            max_elements_caller: options.max_elements,
+        }),
+    });
+    if (error) {
+        console.warn("Error fetching tags for event:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: [],
+        };
+    }
+    return IWebResponse.success(data ?? []).to_compatible();
+}

package/dist/helpers/user_credentials_server.d.ts

@@ -0,0 +1,76 @@
+import { CredentialQueryArgs, UserCredentialInsert, UserCredentialUpdate } from "../types/db";
+export declare function server_get_user_credentials_by_user_id(user_id: string, args?: CredentialQueryArgs): Promise<import("../types").IWebResponseCompatible<{
+    created_at: string;
+    expiration: string | null;
+    file_uri: string | null;
+    id: number;
+    issuer: string;
+    lifecycle: import("../types").Database["public"]["Enums"]["entity_lifecycle"];
+    lifecycle_changed_at: string;
+    lifecycle_changed_by: string | null;
+    lifecycle_reason: string | null;
+    tracking_number: string | null;
+    type: string;
+    updated_at: string;
+    user_id: string;
+}[]>>;
+export declare function server_get_user_credential_by_id(credential_id: number): Promise<import("../types").IWebResponseCompatible<{
+    created_at: string;
+    expiration: string | null;
+    file_uri: string | null;
+    id: number;
+    issuer: string;
+    lifecycle: import("../types").Database["public"]["Enums"]["entity_lifecycle"];
+    lifecycle_changed_at: string;
+    lifecycle_changed_by: string | null;
+    lifecycle_reason: string | null;
+    tracking_number: string | null;
+    type: string;
+    updated_at: string;
+    user_id: string;
+} | null>>;
+export declare function server_create_user_credential(row: UserCredentialInsert): Promise<import("../types").IWebResponseCompatible<{
+    created_at: string;
+    expiration: string | null;
+    file_uri: string | null;
+    id: number;
+    issuer: string;
+    lifecycle: import("../types").Database["public"]["Enums"]["entity_lifecycle"];
+    lifecycle_changed_at: string;
+    lifecycle_changed_by: string | null;
+    lifecycle_reason: string | null;
+    tracking_number: string | null;
+    type: string;
+    updated_at: string;
+    user_id: string;
+} | null>>;
+export declare function server_update_user_credential(credential_id: number, patch: UserCredentialUpdate): Promise<import("../types").IWebResponseCompatible<{
+    created_at: string;
+    expiration: string | null;
+    file_uri: string | null;
+    id: number;
+    issuer: string;
+    lifecycle: import("../types").Database["public"]["Enums"]["entity_lifecycle"];
+    lifecycle_changed_at: string;
+    lifecycle_changed_by: string | null;
+    lifecycle_reason: string | null;
+    tracking_number: string | null;
+    type: string;
+    updated_at: string;
+    user_id: string;
+} | null>>;
+export declare function server_delete_user_credential(credential_id: number): Promise<import("../types").IWebResponseCompatible<{
+    created_at: string;
+    expiration: string | null;
+    file_uri: string | null;
+    id: number;
+    issuer: string;
+    lifecycle: import("../types").Database["public"]["Enums"]["entity_lifecycle"];
+    lifecycle_changed_at: string;
+    lifecycle_changed_by: string | null;
+    lifecycle_reason: string | null;
+    tracking_number: string | null;
+    type: string;
+    updated_at: string;
+    user_id: string;
+} | null>>;

package/dist/helpers/user_credentials_server.js

@@ -0,0 +1,22 @@
+import { newServerClient } from "../supabase/server";
+import { create_user_credential, delete_user_credential, get_user_credential_by_id, get_user_credentials_by_user_id, update_user_credential, } from "./user_credentials";
+export async function server_get_user_credentials_by_user_id(user_id, args) {
+    const client = await newServerClient();
+    return get_user_credentials_by_user_id(client, user_id, args);
+}
+export async function server_get_user_credential_by_id(credential_id) {
+    const client = await newServerClient();
+    return get_user_credential_by_id(client, credential_id);
+}
+export async function server_create_user_credential(row) {
+    const client = await newServerClient();
+    return create_user_credential(client, row);
+}
+export async function server_update_user_credential(credential_id, patch) {
+    const client = await newServerClient();
+    return update_user_credential(client, credential_id, patch);
+}
+export async function server_delete_user_credential(credential_id) {
+    const client = await newServerClient();
+    return delete_user_credential(client, credential_id);
+}

package/dist/helpers/users.d.ts

@@ -1,7 +1,7 @@
 import { IUser, IUserAndRole, IUserProfileRow, IUserRolePerHerd } from "../types/db";
-import { Database } from "../types/supabase";
 import { IWebResponseCompatible } from "../types/requests";
-export type UserProfileUpdate = Database["public"]["Tables"]["users"]["Update"];
+import type { UserProfileUpdate } from "./users.queries";
+export type { UserProfileUpdate } from "./users.queries";
 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): Promise<IWebResponseCompatible<IUserAndRole[]>>;

package/dist/helpers/users.js

@@ -1,125 +1,26 @@
-"use server";
 import { newServerClient } from "../supabase/server";
-import { IWebResponse, EnumWebResponse, } from "../types/requests";
-import { get_users_with_herd_access_batch_query, } from "./users.queries";
+import { get_user_query, get_user_roles_query, get_users_with_herd_access_query, get_users_with_herd_access_batch_query, leave_herd_for_current_user_query, remove_user_from_herd_for_admin_query, update_user_profile_query, upsert_user_herd_role_query, } from "./users.queries";
 export async function server_get_user_roles(herd_id) {
-    const supabase = await newServerClient();
-    // fetch user role for herd
-    const { data, error } = await supabase
-        .from("users_roles_per_herd")
-        .select("*")
-        .eq("herd_id", herd_id);
-    if (!data) {
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: `No user role found for herd ${herd_id}`,
-            data: null,
-        };
-    }
-    // TODO: DETERMINE WHEN TO PASS ERROR
-    let response = IWebResponse.success(data);
-    return response.to_compatible();
+    return get_user_roles_query(await newServerClient(), herd_id);
 }
 export async function server_get_user() {
-    const supabase = await newServerClient();
-    const { data } = await supabase.auth.getUser();
-    const new_user = data.user;
-    return IWebResponse.success(new_user).to_compatible();
+    return get_user_query(await newServerClient());
 }
 export async function server_get_users_with_herd_access(herd_id) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("users_roles_per_herd")
-        .select(`
-      herd_role_id,
-      herd_roles (*),
-      users!users_roles_per_herd_user_id_fkey (*)
-    `)
-        .eq("herd_id", herd_id);
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
-    }
-    const transformedData = (data ?? []).map((item) => ({
-        user: item.users,
-        herd_role_id: item.herd_role_id,
-        herd_role: item.herd_roles,
-    }));
-    return IWebResponse.success(transformedData).to_compatible();
+    return get_users_with_herd_access_query(await newServerClient(), herd_id);
 }
-// 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) {
     return get_users_with_herd_access_batch_query(await newServerClient(), herd_ids);
 }
 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
-        .from("users")
-        .select("*")
-        .eq("username", username)
-        .single();
-    if (user_error) {
-        return IWebResponse.error("Unable to fetch user with provided username").to_compatible();
-    }
-    if (!user) {
-        return IWebResponse.error("User not found").to_compatible();
-    }
-    const { data: herdRole, error: role_error } = await supabase
-        .from("herd_roles")
-        .select("*")
-        .eq("id", herd_role_id)
-        .eq("herd_id", herd_id)
-        .single();
-    if (role_error || !herdRole) {
-        return IWebResponse.error("Invalid herd role for this herd").to_compatible();
-    }
-    const { error } = await supabase.from("users_roles_per_herd").upsert({
-        user_id: user.id,
-        herd_id,
-        herd_role_id,
-    });
-    if (error) {
-        return IWebResponse.error("Unable to update or add user with provided username. Ensure you have sufficient permissions.").to_compatible();
-    }
-    return IWebResponse.success({
-        user,
-        herd_role_id,
-        herd_role: herdRole,
-    }).to_compatible();
+    return upsert_user_herd_role_query(await newServerClient(), herd_id, username, herd_role_id);
 }
 export async function update_user_profile(user_id, patch) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("users")
-        .update(patch)
-        .eq("id", user_id)
-        .select("*")
-        .single();
-    if (error) {
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    if (!data) {
-        return IWebResponse.error("User not found or profile update failed").to_compatible();
-    }
-    return IWebResponse.success(data).to_compatible();
+    return update_user_profile_query(await newServerClient(), user_id, patch);
 }
 export async function leave_herd_for_current_user(herd_id) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase.rpc("leave_herd_for_current_user", {
-        p_herd_id: herd_id,
-    });
-    if (error) {
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    return IWebResponse.success(data).to_compatible();
+    return leave_herd_for_current_user_query(await newServerClient(), herd_id);
 }
 export async function remove_user_from_herd_for_admin(herd_id, user_id) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase.rpc("remove_user_from_herd_for_admin", {
-        p_herd_id: herd_id,
-        p_user_id: user_id,
-    });
-    if (error) {
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    return IWebResponse.success(data).to_compatible();
+    return remove_user_from_herd_for_admin_query(await newServerClient(), herd_id, user_id);
 }