@adventurelabs/scout-core 1.5.5 → 2.0.1

package/dist/helpers/compliance.queries.js

@@ -0,0 +1,167 @@
+import { IWebResponse } from "../types/requests";
+function responseError(message) {
+    return IWebResponse.error(message).to_compatible();
+}
+function pageLimit(options) {
+    const limit = options?.limit ?? 100;
+    return limit < 1 || limit > 500 ? null : limit;
+}
+function updateError(updates) {
+    if (Object.keys(updates).length === 0)
+        return "no fields to update";
+    if (updates.lifecycle_reason !== undefined && updates.lifecycle === undefined) {
+        return "lifecycle_reason requires lifecycle";
+    }
+    return null;
+}
+async function authenticatedUserId(client) {
+    const { data, error } = await client.auth.getUser();
+    return error ? null : (data.user?.id ?? null);
+}
+function withLifecycleActor(updates, userId) {
+    return updates.lifecycle
+        ? { ...updates, lifecycle_changed_by: userId }
+        : updates;
+}
+async function listBy(client, table, column, value, options) {
+    const limit = pageLimit(options);
+    if (limit == null)
+        return responseError("limit must be between 1 and 500");
+    let query = client
+        .from(table)
+        .select("*")
+        .eq(column, value)
+        .order("id")
+        .limit(limit);
+    if (!options?.include_inactive)
+        query = query.eq("lifecycle", "active");
+    if (options?.after_id != null)
+        query = query.gt("id", options.after_id);
+    const { data, error } = await query;
+    return error
+        ? responseError(error.message)
+        : IWebResponse.success((data ?? [])).to_compatible();
+}
+async function listAll(client, table, options) {
+    const limit = pageLimit(options);
+    if (limit == null)
+        return responseError("limit must be between 1 and 500");
+    let query = client.from(table).select("*").order("id").limit(limit);
+    if (!options?.include_inactive)
+        query = query.eq("lifecycle", "active");
+    if (options?.after_id != null)
+        query = query.gt("id", options.after_id);
+    const { data, error } = await query;
+    return error
+        ? responseError(error.message)
+        : IWebResponse.success((data ?? [])).to_compatible();
+}
+async function insertRow(client, table, row) {
+    const { data, error } = await client
+        .from(table)
+        .insert(row)
+        .select("*")
+        .single();
+    return error
+        ? responseError(error.message)
+        : IWebResponse.success(data).to_compatible();
+}
+async function insertWithCreator(client, table, row) {
+    const userId = await authenticatedUserId(client);
+    if (!userId)
+        return responseError("authentication required");
+    return insertRow(client, table, { ...row, created_by: userId });
+}
+async function patchRow(client, table, id, updates, trackUpdater = false) {
+    const invalid = updateError(updates);
+    if (invalid)
+        return responseError(invalid);
+    const userId = await authenticatedUserId(client);
+    if (!userId)
+        return responseError("authentication required");
+    const payload = {
+        ...withLifecycleActor(updates, userId),
+        ...(trackUpdater && { updated_by: userId }),
+    };
+    const { data, error } = await client
+        .from(table)
+        .update(payload)
+        .eq("id", id)
+        .select("*")
+        .single();
+    return error
+        ? responseError(error.message)
+        : IWebResponse.success(data).to_compatible();
+}
+export async function get_contact_types_by_localization_query(client, localizationId, options) {
+    return listBy(client, "contact_types", "localization_id", localizationId, options);
+}
+export async function create_contact_type_query(client, row) {
+    return insertRow(client, "contact_types", row);
+}
+export async function update_contact_type_query(client, id, updates) {
+    return patchRow(client, "contact_types", id, updates);
+}
+export async function get_operating_context_point_of_interest_types_by_localization_query(client, localizationId, options) {
+    return listBy(client, "operating_context_point_of_interest_types", "localization_id", localizationId, options);
+}
+export async function create_operating_context_point_of_interest_type_query(client, row) {
+    return insertRow(client, "operating_context_point_of_interest_types", row);
+}
+export async function update_operating_context_point_of_interest_type_query(client, id, updates) {
+    return patchRow(client, "operating_context_point_of_interest_types", id, updates);
+}
+export async function get_operating_permissions_by_localization_query(client, localizationId, options) {
+    return listBy(client, "operating_permissions", "localization_id", localizationId, options);
+}
+export async function create_operating_permission_query(client, row) {
+    return insertRow(client, "operating_permissions", row);
+}
+export async function update_operating_permission_query(client, id, updates) {
+    return patchRow(client, "operating_permissions", id, updates);
+}
+export async function get_compliance_resource_types_query(client, options) {
+    return listAll(client, "compliance_resource_types", options);
+}
+export async function create_compliance_resource_type_query(client, row) {
+    return insertRow(client, "compliance_resource_types", row);
+}
+export async function update_compliance_resource_type_query(client, id, updates) {
+    return patchRow(client, "compliance_resource_types", id, updates);
+}
+export async function get_compliance_resources_by_localization_query(client, localizationId, options) {
+    return listBy(client, "compliance_resources", "localization_id", localizationId, options);
+}
+export async function create_compliance_resource_query(client, row) {
+    return insertRow(client, "compliance_resources", row);
+}
+export async function update_compliance_resource_query(client, id, updates) {
+    return patchRow(client, "compliance_resources", id, updates);
+}
+export async function get_operating_context_points_of_interest_by_operating_context_query(client, operatingContextId, options) {
+    return listBy(client, "operating_context_points_of_interest", "operating_context_id", operatingContextId, options);
+}
+export async function create_operating_context_point_of_interest_query(client, row) {
+    return insertWithCreator(client, "operating_context_points_of_interest", row);
+}
+export async function update_operating_context_point_of_interest_query(client, id, updates) {
+    return patchRow(client, "operating_context_points_of_interest", id, updates, true);
+}
+export async function get_operating_context_contacts_by_operating_context_query(client, operatingContextId, options) {
+    return listBy(client, "operating_context_contacts", "operating_context_id", operatingContextId, options);
+}
+export async function create_operating_context_contact_query(client, row) {
+    return insertRow(client, "operating_context_contacts", row);
+}
+export async function update_operating_context_contact_query(client, id, updates) {
+    return patchRow(client, "operating_context_contacts", id, updates);
+}
+export async function get_herd_operating_permissions_by_herd_query(client, herdId, options) {
+    return listBy(client, "herd_operating_permissions", "herd_id", herdId, options);
+}
+export async function create_herd_operating_permission_query(client, row) {
+    return insertRow(client, "herd_operating_permissions", row);
+}
+export async function update_herd_operating_permission_query(client, id, updates) {
+    return patchRow(client, "herd_operating_permissions", id, updates);
+}

package/dist/helpers/connectivity.d.ts

@@ -1,5 +1,6 @@
 import { IWebResponseCompatible } from "../types/requests";
 import { IConnectivityWithCoordinates, IConnectivity, ConnectivityInsert, ConnectivityUpdate } from "../types/db";
+import { type HerdConnectivityTimeRangeResponse } from "./connectivity.queries";
 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[]): Promise<IWebResponseCompatible<IConnectivity[]>>;
@@ -8,11 +9,6 @@ export declare function server_update_connectivity(connectivity: (ConnectivityUp
 }) | (ConnectivityUpdate & {
     id: number;
 })[]): Promise<IWebResponseCompatible<IConnectivity[]>>;
-/** Pagination info returned with herd time range connectivity. */
-export type HerdConnectivityTimeRangeResponse = IWebResponseCompatible<IConnectivityWithCoordinates[]> & {
-    hasMore: boolean;
-    nextOffset: number;
-};
 /** Connectivity records for a herd within a time range. Returns most recent rows with hasMore and nextOffset for pagination. */
 export declare function server_get_connectivity_for_herd_time_range(herdId: number, startTimestamp: string, endTimestamp: string, maxCount?: number, offset?: number): Promise<HerdConnectivityTimeRangeResponse>;
 /** Connectivity records for an artifact (uses session when set, else device + time window). */

package/dist/helpers/connectivity.js

@@ -1,155 +1,22 @@
-"use server";
 import { newServerClient } from "../supabase/server";
-import { EnumWebResponse, IWebResponse, } from "../types/requests";
-// Get connectivity by session id using RPC function with coordinates
+import { get_connectivity_by_device_id_query, get_connectivity_by_session_id_query, get_connectivity_for_artifact_query, get_connectivity_for_herd_time_range_query, insert_connectivity_query, update_connectivity_query, } from "./connectivity.queries";
 export async function server_get_connectivity_by_session_id(sessionId) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase.rpc("get_connectivity_with_coordinates", { session_id_caller: sessionId });
-    if (error) {
-        console.warn("Error fetching connectivity by session id:", error.message);
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: [],
-        };
-    }
-    // Sort by timestamp_start in ascending order
-    const sortedConnectivity = (data || []).sort((a, b) => {
-        if (!a.timestamp_start || !b.timestamp_start)
-            return 0;
-        return (new Date(a.timestamp_start).getTime() -
-            new Date(b.timestamp_start).getTime());
-    });
-    return IWebResponse.success(sortedConnectivity).to_compatible();
+    return get_connectivity_by_session_id_query(await newServerClient(), sessionId);
 }
-// Get all connectivity items after a specific timestamp, filtered by device ID
-// Timestamp should be formatted as YYYY-MM-DDTHH:mm:ss.SSSZ
 export async function server_get_connectivity_by_device_id(deviceId, timestamp) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase.rpc("get_connectivity_with_coordinates_by_device_and_timestamp", { device_id_caller: deviceId, timestamp_filter: timestamp });
-    if (error) {
-        console.warn("Error fetching connectivity by session id:", error.message);
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: [],
-        };
-    }
-    // Sort by timestamp_start in ascending order
-    const sortedConnectivity = (data || []).sort((a, b) => {
-        if (!a.timestamp_start || !b.timestamp_start)
-            return 0;
-        return (new Date(a.timestamp_start).getTime() -
-            new Date(b.timestamp_start).getTime());
-    });
-    return IWebResponse.success(sortedConnectivity).to_compatible();
+    return get_connectivity_by_device_id_query(await newServerClient(), deviceId, timestamp);
 }
-// Insert new connectivity records (accepts array for batch operations)
 export async function server_insert_connectivity(connectivity) {
-    const client = await newServerClient();
-    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();
+    return insert_connectivity_query(await newServerClient(), connectivity);
 }
-// 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) {
-    const client = await newServerClient();
-    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();
+    return update_connectivity_query(await newServerClient(), connectivity);
 }
 /** Connectivity records for a herd within a time range. Returns most recent rows with hasMore and nextOffset for pagination. */
 export async function server_get_connectivity_for_herd_time_range(herdId, startTimestamp, endTimestamp, maxCount = 1000, offset = 0) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase.rpc("get_connectivity_for_herd_time_range", {
-        herd_id_caller: herdId,
-        start_timestamp_caller: startTimestamp,
-        end_timestamp_caller: endTimestamp,
-        max_elements_caller: maxCount + 1,
-        offset_caller: offset,
-    });
-    if (error) {
-        console.warn("Error fetching connectivity for herd time range:", error.message);
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: [],
-            hasMore: false,
-            nextOffset: offset,
-        };
-    }
-    const sorted = (data || []).sort((a, b) => {
-        if (!a.timestamp_start || !b.timestamp_start)
-            return 0;
-        return (new Date(a.timestamp_start).getTime() -
-            new Date(b.timestamp_start).getTime());
-    });
-    const hasMore = sorted.length > maxCount;
-    const items = hasMore ? sorted.slice(0, maxCount) : sorted;
-    const nextOffset = offset + items.length;
-    return {
-        ...IWebResponse.success(items).to_compatible(),
-        hasMore,
-        nextOffset,
-    };
+    return get_connectivity_for_herd_time_range_query(await newServerClient(), herdId, startTimestamp, endTimestamp, maxCount, offset);
 }
 /** Connectivity records for an artifact (uses session when set, else device + time window). */
 export async function server_get_connectivity_for_artifact(artifactId, maxElements = 1000) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase.rpc("get_connectivity_for_artifact", {
-        artifact_id_caller: artifactId,
-        max_elements_caller: maxElements,
-    });
-    if (error) {
-        console.warn("Error fetching connectivity for artifact:", error.message);
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: [],
-        };
-    }
-    const sortedConnectivity = (data || []).sort((a, b) => {
-        if (!a.timestamp_start || !b.timestamp_start)
-            return 0;
-        return (new Date(a.timestamp_start).getTime() -
-            new Date(b.timestamp_start).getTime());
-    });
-    return IWebResponse.success(sortedConnectivity).to_compatible();
+    return get_connectivity_for_artifact_query(await newServerClient(), artifactId, maxElements);
 }

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

@@ -0,0 +1,18 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { ConnectivityInsert, ConnectivityUpdate, IConnectivity, IConnectivityWithCoordinates } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+import { Database } from "../types/supabase";
+export type HerdConnectivityTimeRangeResponse = IWebResponseCompatible<IConnectivityWithCoordinates[]> & {
+    hasMore: boolean;
+    nextOffset: number;
+};
+export declare function get_connectivity_by_session_id_query(client: SupabaseClient<Database>, sessionId: number): Promise<IWebResponseCompatible<IConnectivityWithCoordinates[]>>;
+export declare function get_connectivity_by_device_id_query(client: SupabaseClient<Database>, deviceId: number, timestamp: string): Promise<IWebResponseCompatible<IConnectivityWithCoordinates[]>>;
+export declare function insert_connectivity_query(client: SupabaseClient<Database>, connectivity: ConnectivityInsert | ConnectivityInsert[]): Promise<IWebResponseCompatible<IConnectivity[]>>;
+export declare function update_connectivity_query(client: SupabaseClient<Database>, connectivity: (ConnectivityUpdate & {
+    id: number;
+}) | (ConnectivityUpdate & {
+    id: number;
+})[]): Promise<IWebResponseCompatible<IConnectivity[]>>;
+export declare function get_connectivity_for_herd_time_range_query(client: SupabaseClient<Database>, herdId: number, startTimestamp: string, endTimestamp: string, maxCount?: number, offset?: number): Promise<HerdConnectivityTimeRangeResponse>;
+export declare function get_connectivity_for_artifact_query(client: SupabaseClient<Database>, artifactId: number, maxElements?: number): Promise<IWebResponseCompatible<IConnectivityWithCoordinates[]>>;

package/dist/helpers/connectivity.queries.js

@@ -0,0 +1,121 @@
+import { EnumWebResponse, IWebResponse, } from "../types/requests";
+function sortConnectivityByTimestamp(data) {
+    return data.sort((a, b) => {
+        if (!a.timestamp_start || !b.timestamp_start)
+            return 0;
+        return (new Date(a.timestamp_start).getTime() -
+            new Date(b.timestamp_start).getTime());
+    });
+}
+export async function get_connectivity_by_session_id_query(client, sessionId) {
+    const { data, error } = await client.rpc("get_connectivity_with_coordinates", { session_id_caller: sessionId });
+    if (error) {
+        console.warn("Error fetching connectivity by session id:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: [],
+        };
+    }
+    return IWebResponse.success(sortConnectivityByTimestamp(data || [])).to_compatible();
+}
+export async function get_connectivity_by_device_id_query(client, deviceId, timestamp) {
+    const { data, error } = await client.rpc("get_connectivity_with_coordinates_by_device_and_timestamp", { device_id_caller: deviceId, timestamp_filter: timestamp });
+    if (error) {
+        console.warn("Error fetching connectivity by session id:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: [],
+        };
+    }
+    return IWebResponse.success(sortConnectivityByTimestamp(data || [])).to_compatible();
+}
+export async function insert_connectivity_query(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 update_connectivity_query(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();
+}
+export async function get_connectivity_for_herd_time_range_query(client, herdId, startTimestamp, endTimestamp, maxCount = 1000, offset = 0) {
+    const { data, error } = await client.rpc("get_connectivity_for_herd_time_range", {
+        herd_id_caller: herdId,
+        start_timestamp_caller: startTimestamp,
+        end_timestamp_caller: endTimestamp,
+        max_elements_caller: maxCount + 1,
+        offset_caller: offset,
+    });
+    if (error) {
+        console.warn("Error fetching connectivity for herd time range:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: [],
+            hasMore: false,
+            nextOffset: offset,
+        };
+    }
+    const sorted = sortConnectivityByTimestamp(data || []);
+    const hasMore = sorted.length > maxCount;
+    const items = hasMore ? sorted.slice(0, maxCount) : sorted;
+    return {
+        ...IWebResponse.success(items).to_compatible(),
+        hasMore,
+        nextOffset: offset + items.length,
+    };
+}
+export async function get_connectivity_for_artifact_query(client, artifactId, maxElements = 1000) {
+    const { data, error } = await client.rpc("get_connectivity_for_artifact", {
+        artifact_id_caller: artifactId,
+        max_elements_caller: maxElements,
+    });
+    if (error) {
+        console.warn("Error fetching connectivity for artifact:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: [],
+        };
+    }
+    return IWebResponse.success(sortConnectivityByTimestamp(data || [])).to_compatible();
+}

package/dist/helpers/contacts_server.d.ts

@@ -0,0 +1,75 @@
+import { ContactInsert, ContactUpdate } from "../types/db";
+export declare function server_get_contacts_by_herd_id(herd_id: number, options?: {
+    include_inactive?: boolean;
+}): Promise<import("../types").IWebResponseCompatible<{
+    contact_type_id: number | null;
+    created_at: string;
+    created_by: string | null;
+    email: string | null;
+    herd_id: number;
+    id: number;
+    lifecycle: import("../types").Database["public"]["Enums"]["entity_lifecycle"];
+    lifecycle_changed_at: string;
+    lifecycle_changed_by: string | null;
+    lifecycle_reason: string | null;
+    name: string;
+    notes: string | null;
+    phone: string | null;
+    radio_frequency: string | null;
+    updated_at: string;
+    updated_by: string | null;
+}[]>>;
+export declare function server_get_contact_by_id(contact_id: number): Promise<import("../types").IWebResponseCompatible<{
+    contact_type_id: number | null;
+    created_at: string;
+    created_by: string | null;
+    email: string | null;
+    herd_id: number;
+    id: number;
+    lifecycle: import("../types").Database["public"]["Enums"]["entity_lifecycle"];
+    lifecycle_changed_at: string;
+    lifecycle_changed_by: string | null;
+    lifecycle_reason: string | null;
+    name: string;
+    notes: string | null;
+    phone: string | null;
+    radio_frequency: string | null;
+    updated_at: string;
+    updated_by: string | null;
+} | null>>;
+export declare function server_create_contact(row: ContactInsert): Promise<import("../types").IWebResponseCompatible<{
+    contact_type_id: number | null;
+    created_at: string;
+    created_by: string | null;
+    email: string | null;
+    herd_id: number;
+    id: number;
+    lifecycle: import("../types").Database["public"]["Enums"]["entity_lifecycle"];
+    lifecycle_changed_at: string;
+    lifecycle_changed_by: string | null;
+    lifecycle_reason: string | null;
+    name: string;
+    notes: string | null;
+    phone: string | null;
+    radio_frequency: string | null;
+    updated_at: string;
+    updated_by: string | null;
+} | null>>;
+export declare function server_update_contact(contact_id: number, patch: ContactUpdate): Promise<import("../types").IWebResponseCompatible<{
+    contact_type_id: number | null;
+    created_at: string;
+    created_by: string | null;
+    email: string | null;
+    herd_id: number;
+    id: number;
+    lifecycle: import("../types").Database["public"]["Enums"]["entity_lifecycle"];
+    lifecycle_changed_at: string;
+    lifecycle_changed_by: string | null;
+    lifecycle_reason: string | null;
+    name: string;
+    notes: string | null;
+    phone: string | null;
+    radio_frequency: string | null;
+    updated_at: string;
+    updated_by: string | null;
+} | null>>;

package/dist/helpers/contacts_server.js

@@ -0,0 +1,18 @@
+import { newServerClient } from "../supabase/server";
+import { create_contact, get_contact_by_id, get_contacts_by_herd_id, update_contact, } from "./contacts";
+export async function server_get_contacts_by_herd_id(herd_id, options) {
+    const client = await newServerClient();
+    return get_contacts_by_herd_id(client, herd_id, options);
+}
+export async function server_get_contact_by_id(contact_id) {
+    const client = await newServerClient();
+    return get_contact_by_id(client, contact_id);
+}
+export async function server_create_contact(row) {
+    const client = await newServerClient();
+    return create_contact(client, row);
+}
+export async function server_update_contact(contact_id, patch) {
+    const client = await newServerClient();
+    return update_contact(client, contact_id, patch);
+}

package/dist/helpers/deviceTransfer.js

@@ -1,14 +1,5 @@
-"use server";
 import { newServerClient } from "../supabase/server";
-import { IWebResponse } from "../types/requests";
+import { transfer_device_to_herd_query } from "./deviceTransfer.queries";
 export async function transferDeviceToHerd(deviceId, targetHerdId) {
-    const client = await newServerClient();
-    const { error } = await client.rpc("transfer_device_to_herd", {
-        p_device_id: deviceId,
-        p_target_herd_id: targetHerdId,
-    });
-    if (error) {
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    return IWebResponse.success(true).to_compatible();
+    return transfer_device_to_herd_query(await newServerClient(), deviceId, targetHerdId);
 }

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

@@ -0,0 +1,4 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { IWebResponseCompatible } from "../types/requests";
+import { Database } from "../types/supabase";
+export declare function transfer_device_to_herd_query(client: SupabaseClient<Database>, deviceId: number, targetHerdId: number): Promise<IWebResponseCompatible<boolean>>;

package/dist/helpers/deviceTransfer.queries.js

@@ -0,0 +1,11 @@
+import { IWebResponse } from "../types/requests";
+export async function transfer_device_to_herd_query(client, deviceId, targetHerdId) {
+    const { error } = await client.rpc("transfer_device_to_herd", {
+        p_device_id: deviceId,
+        p_target_herd_id: targetHerdId,
+    });
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    return IWebResponse.success(true).to_compatible();
+}