@adventurelabs/scout-core 1.5.4 → 2.0.0

package/dist/helpers/health_metrics.js

@@ -1,43 +1,8 @@
-"use server";
 import { newServerClient } from "../supabase/server";
-import { EnumWebResponse, IWebResponse, } from "../types/requests";
+import { get_health_metrics_query, get_health_metrics_summary_query, } from "./health_metrics.queries";
 export async function server_get_health_metrics(device_id, options) {
-    const supabase = await newServerClient();
-    const lookbackMs = options.lookbackSeconds * 1000;
-    const anchorMs = options.timestampAnchor != null && options.timestampAnchor !== ""
-        ? new Date(options.timestampAnchor).getTime()
-        : Date.now();
-    const startMs = anchorMs - lookbackMs;
-    const startISO = new Date(startMs).toISOString();
-    const endISO = new Date(anchorMs).toISOString();
-    let query = supabase
-        .from("health_metrics")
-        .select("*")
-        .eq("device_id", device_id)
-        .gte("timestamp", startISO)
-        .lt("timestamp", endISO)
-        .order("timestamp", { ascending: false })
-        .limit(options.maxCount);
-    if (options.source != null && options.source !== "") {
-        query = query.eq("source", options.source);
-    }
-    if (options.metricName != null && options.metricName !== "") {
-        query = query.eq("metric_name", options.metricName);
-    }
-    const { data, error } = await query;
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
-    }
-    return IWebResponse.success(data ?? []).to_compatible();
+    return get_health_metrics_query(await newServerClient(), device_id, options);
 }
 export async function server_get_health_metrics_summary(device_id, lookbackMinutes = 60) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase.rpc("get_health_metrics_summary", {
-        p_device_id: device_id,
-        p_lookback_minutes: lookbackMinutes,
-    });
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
-    }
-    return IWebResponse.success(data ?? []).to_compatible();
+    return get_health_metrics_summary_query(await newServerClient(), device_id, lookbackMinutes);
 }

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

@@ -0,0 +1,12 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { IHealthMetric, IHealthMetricSummaryRow } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+import { Database } from "../types/supabase";
+export declare function get_health_metrics_query(client: SupabaseClient<Database>, device_id: number, options: {
+    lookbackSeconds: number;
+    maxCount: number;
+    timestampAnchor?: string | null;
+    source?: string | null;
+    metricName?: string | null;
+}): Promise<IWebResponseCompatible<IHealthMetric[]>>;
+export declare function get_health_metrics_summary_query(client: SupabaseClient<Database>, device_id: number, lookbackMinutes?: number): Promise<IWebResponseCompatible<IHealthMetricSummaryRow[]>>;

package/dist/helpers/health_metrics.queries.js

@@ -0,0 +1,39 @@
+import { EnumWebResponse, IWebResponse, } from "../types/requests";
+export async function get_health_metrics_query(client, device_id, options) {
+    const lookbackMs = options.lookbackSeconds * 1000;
+    const anchorMs = options.timestampAnchor != null && options.timestampAnchor !== ""
+        ? new Date(options.timestampAnchor).getTime()
+        : Date.now();
+    const startMs = anchorMs - lookbackMs;
+    const startISO = new Date(startMs).toISOString();
+    const endISO = new Date(anchorMs).toISOString();
+    let query = client
+        .from("health_metrics")
+        .select("*")
+        .eq("device_id", device_id)
+        .gte("timestamp", startISO)
+        .lt("timestamp", endISO)
+        .order("timestamp", { ascending: false })
+        .limit(options.maxCount);
+    if (options.source != null && options.source !== "") {
+        query = query.eq("source", options.source);
+    }
+    if (options.metricName != null && options.metricName !== "") {
+        query = query.eq("metric_name", options.metricName);
+    }
+    const { data, error } = await query;
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
+    }
+    return IWebResponse.success(data ?? []).to_compatible();
+}
+export async function get_health_metrics_summary_query(client, device_id, lookbackMinutes = 60) {
+    const { data, error } = await client.rpc("get_health_metrics_summary", {
+        p_device_id: device_id,
+        p_lookback_minutes: lookbackMinutes,
+    });
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
+    }
+    return IWebResponse.success(data ?? []).to_compatible();
+}

package/dist/helpers/heartbeats.js

@@ -1,90 +1,11 @@
-"use server";
 import { newServerClient } from "../supabase/server";
-import { EnumWebResponse, IWebResponse, } from "../types/requests";
-// Function to get the last heartbeat for a device
+import { check_device_online_status_query, get_heartbeats_by_device_query, get_last_heartbeat_by_device_query, } from "./heartbeats.queries";
 export async function server_get_last_heartbeat_by_device(device_id) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("heartbeats")
-        .select("*")
-        .eq("device_id", device_id)
-        .order("timestamp", { ascending: false })
-        .limit(1)
-        .single();
-    if (error) {
-        // If no heartbeats found, return null data instead of error
-        if (error.code === "PGRST116") {
-            return {
-                status: EnumWebResponse.SUCCESS,
-                msg: null,
-                data: null,
-            };
-        }
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: null,
-        };
-    }
-    else {
-        return IWebResponse.success(data).to_compatible();
-    }
+    return get_last_heartbeat_by_device_query(await newServerClient(), device_id);
 }
-// Function to get all heartbeats for a device
 export async function server_get_heartbeats_by_device(device_id, limit) {
-    const supabase = await newServerClient();
-    let query = supabase
-        .from("heartbeats")
-        .select("*")
-        .eq("device_id", device_id)
-        .order("timestamp", { ascending: false });
-    if (limit) {
-        query = query.limit(limit);
-    }
-    const { data, error } = await query;
-    if (error) {
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: [],
-        };
-    }
-    else {
-        return IWebResponse.success(data || []).to_compatible();
-    }
+    return get_heartbeats_by_device_query(await newServerClient(), device_id, limit);
 }
-// Function to check if a device is online based on heartbeat recency
 export async function server_check_device_online_status(device_id, offline_threshold_minutes = 5) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("heartbeats")
-        .select("*")
-        .eq("device_id", device_id)
-        .order("timestamp", { ascending: false })
-        .limit(1)
-        .single();
-    if (error) {
-        // If no heartbeats found
-        if (error.code === "PGRST116") {
-            return IWebResponse.success({
-                is_online: false,
-                last_heartbeat: null,
-                minutes_since_last_heartbeat: null,
-            }).to_compatible();
-        }
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: null,
-        };
-    }
-    const now = new Date();
-    const heartbeatTime = new Date(data.timestamp);
-    const minutesSinceLastHeartbeat = Math.floor((now.getTime() - heartbeatTime.getTime()) / (1000 * 60));
-    const isOnline = minutesSinceLastHeartbeat <= offline_threshold_minutes;
-    return IWebResponse.success({
-        is_online: isOnline,
-        last_heartbeat: data,
-        minutes_since_last_heartbeat: minutesSinceLastHeartbeat,
-    }).to_compatible();
+    return check_device_online_status_query(await newServerClient(), device_id, offline_threshold_minutes);
 }

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

@@ -0,0 +1,11 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { IHeartbeat } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+import { Database } from "../types/supabase";
+export declare function get_last_heartbeat_by_device_query(client: SupabaseClient<Database>, device_id: number): Promise<IWebResponseCompatible<IHeartbeat | null>>;
+export declare function get_heartbeats_by_device_query(client: SupabaseClient<Database>, device_id: number, limit?: number): Promise<IWebResponseCompatible<IHeartbeat[]>>;
+export declare function check_device_online_status_query(client: SupabaseClient<Database>, device_id: number, offline_threshold_minutes?: number): Promise<IWebResponseCompatible<{
+    is_online: boolean;
+    last_heartbeat: IHeartbeat | null;
+    minutes_since_last_heartbeat: number | null;
+}>>;

package/dist/helpers/heartbeats.queries.js

@@ -0,0 +1,76 @@
+import { EnumWebResponse, IWebResponse, } from "../types/requests";
+export async function get_last_heartbeat_by_device_query(client, device_id) {
+    const { data, error } = await client
+        .from("heartbeats")
+        .select("*")
+        .eq("device_id", device_id)
+        .order("timestamp", { ascending: false })
+        .limit(1)
+        .single();
+    if (error) {
+        if (error.code === "PGRST116") {
+            return {
+                status: EnumWebResponse.SUCCESS,
+                msg: null,
+                data: null,
+            };
+        }
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: null,
+        };
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function get_heartbeats_by_device_query(client, device_id, limit) {
+    let query = client
+        .from("heartbeats")
+        .select("*")
+        .eq("device_id", device_id)
+        .order("timestamp", { ascending: false });
+    if (limit) {
+        query = query.limit(limit);
+    }
+    const { data, error } = await query;
+    if (error) {
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: [],
+        };
+    }
+    return IWebResponse.success(data || []).to_compatible();
+}
+export async function check_device_online_status_query(client, device_id, offline_threshold_minutes = 5) {
+    const { data, error } = await client
+        .from("heartbeats")
+        .select("*")
+        .eq("device_id", device_id)
+        .order("timestamp", { ascending: false })
+        .limit(1)
+        .single();
+    if (error) {
+        if (error.code === "PGRST116") {
+            return IWebResponse.success({
+                is_online: false,
+                last_heartbeat: null,
+                minutes_since_last_heartbeat: null,
+            }).to_compatible();
+        }
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: null,
+        };
+    }
+    const now = new Date();
+    const heartbeatTime = new Date(data.timestamp);
+    const minutesSinceLastHeartbeat = Math.floor((now.getTime() - heartbeatTime.getTime()) / (1000 * 60));
+    const isOnline = minutesSinceLastHeartbeat <= offline_threshold_minutes;
+    return IWebResponse.success({
+        is_online: isOnline,
+        last_heartbeat: data,
+        minutes_since_last_heartbeat: minutesSinceLastHeartbeat,
+    }).to_compatible();
+}

package/dist/helpers/herd_allowed_domains.js

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

package/dist/helpers/{herd_allowed_domains_internal.d.ts → herd_allowed_domains.queries.d.ts}

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

package/dist/helpers/{herd_allowed_domains_internal.js → herd_allowed_domains.queries.js}

@@ -1,6 +1,6 @@
 import { IWebResponse } from "../types/requests";
-export async function getHerdAllowedDomainsWithClient(supabase, herd_id) {
-    const { data, error } = await supabase
+export async function get_herd_allowed_domains_query(client, herd_id) {
+    const { data, error } = await client
         .from("herd_allowed_domains")
         .select("*")
         .eq("herd_id", herd_id)

package/dist/helpers/herd_credentials_server.d.ts

@@ -0,0 +1,76 @@
+import { CredentialQueryArgs, HerdCredentialInsert, HerdCredentialUpdate } from "../types/db";
+export declare function server_get_herd_credentials_by_herd_id(herd_id: number, args?: CredentialQueryArgs): Promise<import("../types").IWebResponseCompatible<{
+    created_at: string;
+    expiration: string | null;
+    file_uri: string | null;
+    herd_id: number;
+    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;
+}[]>>;
+export declare function server_get_herd_credential_by_id(credential_id: number): Promise<import("../types").IWebResponseCompatible<{
+    created_at: string;
+    expiration: string | null;
+    file_uri: string | null;
+    herd_id: number;
+    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;
+} | null>>;
+export declare function server_create_herd_credential(row: HerdCredentialInsert): Promise<import("../types").IWebResponseCompatible<{
+    created_at: string;
+    expiration: string | null;
+    file_uri: string | null;
+    herd_id: number;
+    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;
+} | null>>;
+export declare function server_update_herd_credential(credential_id: number, patch: HerdCredentialUpdate): Promise<import("../types").IWebResponseCompatible<{
+    created_at: string;
+    expiration: string | null;
+    file_uri: string | null;
+    herd_id: number;
+    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;
+} | null>>;
+export declare function server_delete_herd_credential(credential_id: number): Promise<import("../types").IWebResponseCompatible<{
+    created_at: string;
+    expiration: string | null;
+    file_uri: string | null;
+    herd_id: number;
+    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;
+} | null>>;

package/dist/helpers/herd_credentials_server.js

@@ -0,0 +1,22 @@
+import { newServerClient } from "../supabase/server";
+import { create_herd_credential, delete_herd_credential, get_herd_credential_by_id, get_herd_credentials_by_herd_id, update_herd_credential, } from "./herd_credentials";
+export async function server_get_herd_credentials_by_herd_id(herd_id, args) {
+    const client = await newServerClient();
+    return get_herd_credentials_by_herd_id(client, herd_id, args);
+}
+export async function server_get_herd_credential_by_id(credential_id) {
+    const client = await newServerClient();
+    return get_herd_credential_by_id(client, credential_id);
+}
+export async function server_create_herd_credential(row) {
+    const client = await newServerClient();
+    return create_herd_credential(client, row);
+}
+export async function server_update_herd_credential(credential_id, patch) {
+    const client = await newServerClient();
+    return update_herd_credential(client, credential_id, patch);
+}
+export async function server_delete_herd_credential(credential_id) {
+    const client = await newServerClient();
+    return delete_herd_credential(client, credential_id);
+}

package/dist/helpers/herd_modules.queries.js

@@ -1,4 +1,3 @@
-import { createHash } from "crypto";
 import { list_api_keys_batch_query } from "../api_keys/queries";
 import { LABELS } from "../constants/annotator";
 import { EnumWebResponse, } from "../types/requests";
@@ -9,10 +8,14 @@ import { get_parts_by_herd_ids } from "./parts";
 import { get_session_summaries_query } from "./session_summaries.queries";
 import { get_session_usage_over_time_by_herd_query } from "./sessions.queries";
 import { get_users_with_herd_access_batch_query } from "./users.queries";
-import { server_get_more_zones_and_actions_for_herd } from "./zones";
-function hashHerdModules(modules) {
+import { get_more_zones_and_actions_for_herd_query } from "./zones.queries";
+async function hashHerdModules(modules) {
     const stable = modules.map(({ timestamp_last_refreshed: _ts, ...rest }) => rest);
-    return createHash("sha1").update(JSON.stringify(stable)).digest("hex");
+    const bytes = new TextEncoder().encode(JSON.stringify(stable));
+    const digest = await crypto.subtle.digest("SHA-1", bytes);
+    return Array.from(new Uint8Array(digest))
+        .map((byte) => byte.toString(16).padStart(2, "0"))
+        .join("");
 }
 export async function load_herd_modules_query(client) {
     const startTime = Date.now();
@@ -39,7 +42,7 @@ export async function load_herd_modules_query(client) {
             time_finished: endTime,
             time_sent: endTime,
             server_processing_time_ms: endTime - startTime,
-            content_hash: hashHerdModules([]),
+            content_hash: await hashHerdModules([]),
         };
     }
     const herdIds = herds.map((herd) => herd.id);
@@ -59,7 +62,7 @@ export async function load_herd_modules_query(client) {
             .catch(() => null),
         grouped(get_parts_by_herd_ids(client, herdIds)),
         perHerd((id) => get_devices_by_herd_query(client, id)),
-        perHerd((id) => server_get_more_zones_and_actions_for_herd(id, 0, 10, client)),
+        perHerd((id) => get_more_zones_and_actions_for_herd_query(client, id, 0, 10)),
         perHerd((id) => get_session_summaries_query(client, { herd_id: id })),
         perHerd((id) => get_session_usage_over_time_by_herd_query(client, id)),
     ]);
@@ -101,6 +104,6 @@ export async function load_herd_modules_query(client) {
         time_finished: endTime,
         time_sent: endTime,
         server_processing_time_ms: endTime - startTime,
-        content_hash: hashHerdModules(serialized_herd_modules),
+        content_hash: await hashHerdModules(serialized_herd_modules),
     };
 }

package/dist/helpers/herd_roles.js

@@ -1,173 +1,38 @@
-"use server";
-import { IWebResponse } from "../types/requests";
 import { newServerClient } from "../supabase/server";
+import { create_herd_role_query, delete_herd_role_query, get_abilities_by_ids_query, get_herd_role_by_system_name_query, get_herd_roles_query, get_herd_roles_with_abilities_query, get_platform_default_role_abilities_query, list_abilities_query, reset_herd_default_role_abilities_query, set_herd_role_abilities_query, set_platform_default_role_abilities_query, update_herd_role_query, } from "./herd_roles.queries";
 export async function server_list_abilities() {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("abilities")
-        .select("*")
-        .order("key", { ascending: true });
-    if (error) {
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    return IWebResponse.success(data ?? []).to_compatible();
+    return list_abilities_query(await newServerClient());
 }
 export async function server_get_abilities_by_ids(ids) {
-    if (ids.length === 0) {
-        return IWebResponse.success([]).to_compatible();
-    }
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("abilities")
-        .select("*")
-        .in("id", ids)
-        .order("key", { ascending: true });
-    if (error) {
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    return IWebResponse.success(data ?? []).to_compatible();
+    return get_abilities_by_ids_query(await newServerClient(), ids);
 }
 export async function server_get_herd_roles(herd_id) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("herd_roles")
-        .select("*")
-        .eq("herd_id", herd_id)
-        .order("system_name", { ascending: true });
-    if (error) {
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    return IWebResponse.success(data ?? []).to_compatible();
+    return get_herd_roles_query(await newServerClient(), herd_id);
 }
 export async function server_get_herd_roles_with_abilities(herd_id) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("herd_roles")
-        .select(`
-      *,
-      herd_role_abilities (
-        id,
-        ability_id,
-        abilities (*)
-      )
-    `)
-        .eq("herd_id", herd_id)
-        .order("system_name", { ascending: true });
-    if (error) {
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    const rows = (data ?? []).map((row) => {
-        const { herd_role_abilities: matrix, ...role } = row;
-        const links = matrix ?? [];
-        return {
-            ...role,
-            abilities: links
-                .map((m) => m.abilities)
-                .filter((a) => a != null),
-            ability_ids: links.map((m) => m.ability_id),
-        };
-    });
-    return IWebResponse.success(rows).to_compatible();
+    return get_herd_roles_with_abilities_query(await newServerClient(), herd_id);
 }
 export async function server_get_herd_role_by_system_name(herd_id, system_name) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("herd_roles")
-        .select("*")
-        .eq("herd_id", herd_id)
-        .eq("system_name", system_name)
-        .maybeSingle();
-    if (error) {
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    return IWebResponse.success(data).to_compatible();
+    return get_herd_role_by_system_name_query(await newServerClient(), herd_id, system_name);
 }
 export async function server_create_herd_role(herd_id, system_name, name) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("herd_roles")
-        .insert({ herd_id, system_name, name, is_system: false })
-        .select("*")
-        .single();
-    if (error) {
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    return IWebResponse.success(data).to_compatible();
+    return create_herd_role_query(await newServerClient(), herd_id, system_name, name);
 }
 export async function server_update_herd_role(herd_role_id, patch) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("herd_roles")
-        .update(patch)
-        .eq("id", herd_role_id)
-        .select("*")
-        .single();
-    if (error) {
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    return IWebResponse.success(data).to_compatible();
+    return update_herd_role_query(await newServerClient(), herd_role_id, patch);
 }
 export async function server_delete_herd_role(herd_role_id) {
-    const supabase = await newServerClient();
-    const { error } = await supabase
-        .from("herd_roles")
-        .delete()
-        .eq("id", herd_role_id);
-    if (error) {
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    return IWebResponse.success(null).to_compatible();
+    return delete_herd_role_query(await newServerClient(), herd_role_id);
 }
 export async function server_set_herd_role_abilities(herd_role_id, ability_ids) {
-    const supabase = await newServerClient();
-    const { error: deleteError } = await supabase
-        .from("herd_role_abilities")
-        .delete()
-        .eq("herd_role_id", herd_role_id);
-    if (deleteError) {
-        return IWebResponse.error(deleteError.message).to_compatible();
-    }
-    if (ability_ids.length === 0) {
-        return IWebResponse.success([]).to_compatible();
-    }
-    const { data, error } = await supabase
-        .from("herd_role_abilities")
-        .insert(ability_ids.map((ability_id) => ({ herd_role_id, ability_id })))
-        .select("*");
-    if (error) {
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    return IWebResponse.success(data ?? []).to_compatible();
+    return set_herd_role_abilities_query(await newServerClient(), herd_role_id, ability_ids);
 }
 export async function server_get_platform_default_role_abilities() {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase.rpc("get_platform_default_role_abilities");
-    if (error) {
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    const groups = Array.isArray(data)
-        ? data
-        : [];
-    return IWebResponse.success(groups).to_compatible();
+    return get_platform_default_role_abilities_query(await newServerClient());
 }
 export async function server_set_platform_default_role_abilities(system_name, ability_keys) {
-    const supabase = await newServerClient();
-    const { error } = await supabase.rpc("set_platform_default_role_abilities", {
-        p_system_name: system_name,
-        p_ability_keys: ability_keys,
-    });
-    if (error) {
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    return IWebResponse.success(null).to_compatible();
+    return set_platform_default_role_abilities_query(await newServerClient(), system_name, ability_keys);
 }
 export async function server_reset_herd_default_role_abilities(herd_id) {
-    const supabase = await newServerClient();
-    const { error } = await supabase.rpc("reset_herd_default_role_abilities", {
-        p_herd_id: herd_id,
-    });
-    if (error) {
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    return IWebResponse.success(null).to_compatible();
+    return reset_herd_default_role_abilities_query(await newServerClient(), herd_id);
 }