@adventurelabs/scout-core 1.5.5 → 2.0.1

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);
 }

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

@@ -0,0 +1,18 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { IAbility, IHerdRole, IHerdRoleAbilityRow, IHerdRoleWithAbilities, IPlatformDefaultRoleAbilitiesGroup } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+import { Database } from "../types/supabase";
+export declare function list_abilities_query(client: SupabaseClient<Database>): Promise<IWebResponseCompatible<IAbility[]>>;
+export declare function get_abilities_by_ids_query(client: SupabaseClient<Database>, ids: number[]): Promise<IWebResponseCompatible<IAbility[]>>;
+export declare function get_herd_roles_query(client: SupabaseClient<Database>, herd_id: number): Promise<IWebResponseCompatible<IHerdRole[]>>;
+export declare function get_herd_roles_with_abilities_query(client: SupabaseClient<Database>, herd_id: number): Promise<IWebResponseCompatible<IHerdRoleWithAbilities[]>>;
+export declare function get_herd_role_by_system_name_query(client: SupabaseClient<Database>, herd_id: number, system_name: string): Promise<IWebResponseCompatible<IHerdRole | null>>;
+export declare function create_herd_role_query(client: SupabaseClient<Database>, herd_id: number, system_name: string, name: string): Promise<IWebResponseCompatible<IHerdRole | null>>;
+export declare function update_herd_role_query(client: SupabaseClient<Database>, herd_role_id: number, patch: {
+    name?: string;
+}): Promise<IWebResponseCompatible<IHerdRole | null>>;
+export declare function delete_herd_role_query(client: SupabaseClient<Database>, herd_role_id: number): Promise<IWebResponseCompatible<null>>;
+export declare function set_herd_role_abilities_query(client: SupabaseClient<Database>, herd_role_id: number, ability_ids: number[]): Promise<IWebResponseCompatible<IHerdRoleAbilityRow[]>>;
+export declare function get_platform_default_role_abilities_query(client: SupabaseClient<Database>): Promise<IWebResponseCompatible<IPlatformDefaultRoleAbilitiesGroup[]>>;
+export declare function set_platform_default_role_abilities_query(client: SupabaseClient<Database>, system_name: string, ability_keys: string[]): Promise<IWebResponseCompatible<null>>;
+export declare function reset_herd_default_role_abilities_query(client: SupabaseClient<Database>, herd_id: number): Promise<IWebResponseCompatible<null>>;

package/dist/helpers/{herd_roles_internal.js → herd_roles.queries.js}

@@ -1,6 +1,6 @@
 import { IWebResponse } from "../types/requests";
-export async function listAbilitiesWithClient(supabase) {
-    const { data, error } = await supabase
+export async function list_abilities_query(client) {
+    const { data, error } = await client
         .from("abilities")
         .select("*")
         .order("key", { ascending: true });
@@ -9,11 +9,11 @@ export async function listAbilitiesWithClient(supabase) {
     }
     return IWebResponse.success(data ?? []).to_compatible();
 }
-export async function getAbilitiesByIdsWithClient(supabase, ids) {
+export async function get_abilities_by_ids_query(client, ids) {
     if (ids.length === 0) {
         return IWebResponse.success([]).to_compatible();
     }
-    const { data, error } = await supabase
+    const { data, error } = await client
         .from("abilities")
         .select("*")
         .in("id", ids)
@@ -23,8 +23,8 @@ export async function getAbilitiesByIdsWithClient(supabase, ids) {
     }
     return IWebResponse.success(data ?? []).to_compatible();
 }
-export async function getHerdRolesWithClient(supabase, herd_id) {
-    const { data, error } = await supabase
+export async function get_herd_roles_query(client, herd_id) {
+    const { data, error } = await client
         .from("herd_roles")
         .select("*")
         .eq("herd_id", herd_id)
@@ -34,8 +34,8 @@ export async function getHerdRolesWithClient(supabase, herd_id) {
     }
     return IWebResponse.success(data ?? []).to_compatible();
 }
-export async function getHerdRolesWithAbilitiesWithClient(supabase, herd_id) {
-    const { data, error } = await supabase
+export async function get_herd_roles_with_abilities_query(client, herd_id) {
+    const { data, error } = await client
         .from("herd_roles")
         .select(`
       *,
@@ -56,15 +56,15 @@ export async function getHerdRolesWithAbilitiesWithClient(supabase, herd_id) {
         return {
             ...role,
             abilities: links
-                .map((m) => m.abilities)
-                .filter((a) => a != null),
-            ability_ids: links.map((m) => m.ability_id),
+                .map((link) => link.abilities)
+                .filter((ability) => ability != null),
+            ability_ids: links.map((link) => link.ability_id),
         };
     });
     return IWebResponse.success(rows).to_compatible();
 }
-export async function getHerdRoleBySystemNameWithClient(supabase, herd_id, system_name) {
-    const { data, error } = await supabase
+export async function get_herd_role_by_system_name_query(client, herd_id, system_name) {
+    const { data, error } = await client
         .from("herd_roles")
         .select("*")
         .eq("herd_id", herd_id)
@@ -75,8 +75,8 @@ export async function getHerdRoleBySystemNameWithClient(supabase, herd_id, syste
     }
     return IWebResponse.success(data).to_compatible();
 }
-export async function createHerdRoleWithClient(supabase, herd_id, system_name, name) {
-    const { data, error } = await supabase
+export async function create_herd_role_query(client, herd_id, system_name, name) {
+    const { data, error } = await client
         .from("herd_roles")
         .insert({ herd_id, system_name, name, is_system: false })
         .select("*")
@@ -86,8 +86,8 @@ export async function createHerdRoleWithClient(supabase, herd_id, system_name, n
     }
     return IWebResponse.success(data).to_compatible();
 }
-export async function updateHerdRoleWithClient(supabase, herd_role_id, patch) {
-    const { data, error } = await supabase
+export async function update_herd_role_query(client, herd_role_id, patch) {
+    const { data, error } = await client
         .from("herd_roles")
         .update(patch)
         .eq("id", herd_role_id)
@@ -98,8 +98,8 @@ export async function updateHerdRoleWithClient(supabase, herd_role_id, patch) {
     }
     return IWebResponse.success(data).to_compatible();
 }
-export async function deleteHerdRoleWithClient(supabase, herd_role_id) {
-    const { error } = await supabase
+export async function delete_herd_role_query(client, herd_role_id) {
+    const { error } = await client
         .from("herd_roles")
         .delete()
         .eq("id", herd_role_id);
@@ -108,8 +108,8 @@ export async function deleteHerdRoleWithClient(supabase, herd_role_id) {
     }
     return IWebResponse.success(null).to_compatible();
 }
-export async function setHerdRoleAbilitiesWithClient(supabase, herd_role_id, ability_ids) {
-    const { error: deleteError } = await supabase
+export async function set_herd_role_abilities_query(client, herd_role_id, ability_ids) {
+    const { error: deleteError } = await client
         .from("herd_role_abilities")
         .delete()
         .eq("herd_role_id", herd_role_id);
@@ -119,7 +119,7 @@ export async function setHerdRoleAbilitiesWithClient(supabase, herd_role_id, abi
     if (ability_ids.length === 0) {
         return IWebResponse.success([]).to_compatible();
     }
-    const { data, error } = await supabase
+    const { data, error } = await client
         .from("herd_role_abilities")
         .insert(ability_ids.map((ability_id) => ({ herd_role_id, ability_id })))
         .select("*");
@@ -128,8 +128,8 @@ export async function setHerdRoleAbilitiesWithClient(supabase, herd_role_id, abi
     }
     return IWebResponse.success(data ?? []).to_compatible();
 }
-export async function getPlatformDefaultRoleAbilitiesWithClient(supabase) {
-    const { data, error } = await supabase.rpc("get_platform_default_role_abilities");
+export async function get_platform_default_role_abilities_query(client) {
+    const { data, error } = await client.rpc("get_platform_default_role_abilities");
     if (error) {
         return IWebResponse.error(error.message).to_compatible();
     }
@@ -138,8 +138,8 @@ export async function getPlatformDefaultRoleAbilitiesWithClient(supabase) {
         : [];
     return IWebResponse.success(groups).to_compatible();
 }
-export async function setPlatformDefaultRoleAbilitiesWithClient(supabase, system_name, ability_keys) {
-    const { error } = await supabase.rpc("set_platform_default_role_abilities", {
+export async function set_platform_default_role_abilities_query(client, system_name, ability_keys) {
+    const { error } = await client.rpc("set_platform_default_role_abilities", {
         p_system_name: system_name,
         p_ability_keys: ability_keys,
     });
@@ -148,8 +148,8 @@ export async function setPlatformDefaultRoleAbilitiesWithClient(supabase, system
     }
     return IWebResponse.success(null).to_compatible();
 }
-export async function resetHerdDefaultRoleAbilitiesWithClient(supabase, herd_id) {
-    const { error } = await supabase.rpc("reset_herd_default_role_abilities", {
+export async function reset_herd_default_role_abilities_query(client, herd_id) {
+    const { error } = await client.rpc("reset_herd_default_role_abilities", {
         p_herd_id: herd_id,
     });
     if (error) {

package/dist/helpers/herds.js

@@ -1,62 +1,20 @@
-"use server";
 import { newServerClient } from "../supabase/server";
-import { EnumWebResponse, IWebResponse, } from "../types/requests";
-import { get_herds_with_location_query } from "./herds.queries";
+import { create_herd_query, delete_herd_query, get_herd_by_slug_query, get_herds_query, get_herds_with_location_query, } from "./herds.queries";
 import { load_herd_modules_query } from "./herd_modules.queries";
 export async function get_herds() {
-    const supabase = await newServerClient();
-    const { data: herds } = await supabase.from("herds").select();
-    if (!herds) {
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: "No herds found",
-            data: null,
-        };
-    }
-    return IWebResponse.success(herds).to_compatible();
+    return get_herds_query(await newServerClient());
 }
 export async function get_herds_with_location() {
     return get_herds_with_location_query(await newServerClient());
 }
 export async function get_herd_by_slug(slug) {
-    const supabase = await newServerClient();
-    const { data: herds } = await supabase
-        .from("herds")
-        .select()
-        .eq("slug", slug)
-        .limit(1);
-    if (!herds) {
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: "No herds found",
-            data: null,
-        };
-    }
-    return IWebResponse.success(herds[0]);
+    return get_herd_by_slug_query(await newServerClient(), slug);
 }
 export async function deleteHerd(herd_id) {
-    const supabase = await newServerClient();
-    const { error } = await supabase.from("herds").delete().match({ id: herd_id });
-    if (error) {
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: null,
-        };
-    }
-    return IWebResponse.success(true).to_compatible();
+    return delete_herd_query(await newServerClient(), herd_id);
 }
 export async function createHerd(newHerd) {
-    const supabase = await newServerClient();
-    const { error } = await supabase.from("herds").insert([newHerd]);
-    if (error) {
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: null,
-        };
-    }
-    return IWebResponse.success(true).to_compatible();
+    return create_herd_query(await newServerClient(), newHerd);
 }
 export async function server_load_herd_modules() {
     return load_herd_modules_query(await newServerClient());

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

@@ -1,5 +1,12 @@
 import { SupabaseClient } from "@supabase/supabase-js";
-import { IHerdPrettyLocation } from "../types/db";
+import { IHerd, IHerdPrettyLocation } from "../types/db";
 import { Database } from "../types/supabase";
 import { IWebResponseCompatible } from "../types/requests";
+export declare function get_herds_query(client: SupabaseClient<Database>): Promise<IWebResponseCompatible<IHerd[]>>;
 export declare function get_herds_with_location_query(client: SupabaseClient<Database>): Promise<IWebResponseCompatible<IHerdPrettyLocation[]>>;
+export declare function get_herd_by_slug_query(client: SupabaseClient<Database>, slug: string): Promise<IWebResponseCompatible<IHerd>>;
+export declare function delete_herd_query(client: SupabaseClient<Database>, herd_id: number): Promise<IWebResponseCompatible<boolean>>;
+export declare function create_herd_query(client: SupabaseClient<Database>, newHerd: Omit<IHerd, "id" | "inserted_at"> & {
+    id?: number;
+    inserted_at?: string;
+}): Promise<IWebResponseCompatible<boolean>>;

package/dist/helpers/herds.queries.js

@@ -1,4 +1,15 @@
 import { EnumWebResponse, IWebResponse, } from "../types/requests";
+export async function get_herds_query(client) {
+    const { data: herds } = await client.from("herds").select();
+    if (!herds) {
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: "No herds found",
+            data: null,
+        };
+    }
+    return IWebResponse.success(herds).to_compatible();
+}
 export async function get_herds_with_location_query(client) {
     const { data, error } = await client.rpc("get_herds_with_location");
     if (error) {
@@ -10,3 +21,40 @@ export async function get_herds_with_location_query(client) {
     }
     return IWebResponse.success(data ?? []).to_compatible();
 }
+export async function get_herd_by_slug_query(client, slug) {
+    const { data: herds } = await client
+        .from("herds")
+        .select()
+        .eq("slug", slug)
+        .limit(1);
+    if (!herds) {
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: "No herds found",
+            data: null,
+        };
+    }
+    return IWebResponse.success(herds[0]);
+}
+export async function delete_herd_query(client, herd_id) {
+    const { error } = await client.from("herds").delete().match({ id: herd_id });
+    if (error) {
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: null,
+        };
+    }
+    return IWebResponse.success(true).to_compatible();
+}
+export async function create_herd_query(client, newHerd) {
+    const { error } = await client.from("herds").insert([newHerd]);
+    if (error) {
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: null,
+        };
+    }
+    return IWebResponse.success(true).to_compatible();
+}

package/dist/helpers/invitations.js

@@ -1,71 +1,20 @@
-"use server";
 import { newServerClient } from "../supabase/server";
-import { IWebResponse } from "../types/requests";
+import { accept_herd_invitations_for_current_user_query, create_herd_invitation_query, get_herd_invitations_by_herd_query, get_herd_invitations_for_current_user_query, reject_herd_invitations_for_current_user_query, revoke_herd_invitations_query, } from "./invitations.queries";
 export async function server_create_herd_invitation(herd_id, email, herd_role_id, expires_at) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase.rpc("create_herd_invitation", {
-        p_herd_id: herd_id,
-        p_email: email,
-        p_herd_role_id: herd_role_id,
-        p_expires_at: expires_at ?? undefined,
-    });
-    if (error) {
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    return IWebResponse.success(data).to_compatible();
+    return create_herd_invitation_query(await newServerClient(), herd_id, email, herd_role_id, expires_at);
 }
 export async function accept_herd_invitations_for_current_user(invitation_ids) {
-    if (invitation_ids.length === 0) {
-        return IWebResponse.error("At least one invitation id is required").to_compatible();
-    }
-    const supabase = await newServerClient();
-    const { data, error } = await supabase.rpc("accept_herd_invitations_for_current_user", { p_invitation_ids: invitation_ids });
-    if (error) {
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    return IWebResponse.success(data ?? []).to_compatible();
+    return accept_herd_invitations_for_current_user_query(await newServerClient(), invitation_ids);
 }
 export async function server_get_herd_invitations_for_current_user() {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase.rpc("get_herd_invitations_for_current_user");
-    if (error) {
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    return IWebResponse.success(data ?? []).to_compatible();
+    return get_herd_invitations_for_current_user_query(await newServerClient());
 }
 export async function server_get_herd_invitations_by_herd(herd_id) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("herd_invitations")
-        .select("*")
-        .eq("herd_id", herd_id)
-        .order("created_at", { ascending: false });
-    if (error) {
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    return IWebResponse.success(data ?? []).to_compatible();
+    return get_herd_invitations_by_herd_query(await newServerClient(), herd_id);
 }
 export async function reject_herd_invitations_for_current_user(invitation_ids) {
-    if (invitation_ids.length === 0) {
-        return IWebResponse.error("At least one invitation id is required").to_compatible();
-    }
-    const supabase = await newServerClient();
-    const { data, error } = await supabase.rpc("reject_herd_invitations_for_current_user", { p_invitation_ids: invitation_ids });
-    if (error) {
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    return IWebResponse.success(data ?? []).to_compatible();
+    return reject_herd_invitations_for_current_user_query(await newServerClient(), invitation_ids);
 }
 export async function server_revoke_herd_invitations(invitation_ids) {
-    if (invitation_ids.length === 0) {
-        return IWebResponse.error("At least one invitation id is required").to_compatible();
-    }
-    const supabase = await newServerClient();
-    const { data, error } = await supabase.rpc("revoke_herd_invitations", {
-        p_invitation_ids: invitation_ids,
-    });
-    if (error) {
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    return IWebResponse.success(data ?? []).to_compatible();
+    return revoke_herd_invitations_query(await newServerClient(), invitation_ids);
 }

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

@@ -0,0 +1,10 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { IHerdInvitation, IHerdInvitationWithHerdSlug } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+import { Database } from "../types/supabase";
+export declare function create_herd_invitation_query(client: SupabaseClient<Database>, herd_id: number, email: string, herd_role_id: number, expires_at?: string | null): Promise<IWebResponseCompatible<IHerdInvitation | null>>;
+export declare function accept_herd_invitations_for_current_user_query(client: SupabaseClient<Database>, invitation_ids: number[]): Promise<IWebResponseCompatible<IHerdInvitation[]>>;
+export declare function get_herd_invitations_for_current_user_query(client: SupabaseClient<Database>): Promise<IWebResponseCompatible<IHerdInvitationWithHerdSlug[]>>;
+export declare function get_herd_invitations_by_herd_query(client: SupabaseClient<Database>, herd_id: number): Promise<IWebResponseCompatible<IHerdInvitation[]>>;
+export declare function reject_herd_invitations_for_current_user_query(client: SupabaseClient<Database>, invitation_ids: number[]): Promise<IWebResponseCompatible<IHerdInvitation[]>>;
+export declare function revoke_herd_invitations_query(client: SupabaseClient<Database>, invitation_ids: number[]): Promise<IWebResponseCompatible<IHerdInvitation[]>>;