@adventurelabs/scout-core 1.5.4 → 2.0.0

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[]>>;

package/dist/helpers/{invitations_internal.js → invitations.queries.js}

@@ -1,6 +1,6 @@
 import { IWebResponse } from "../types/requests";
-export async function createHerdInvitationWithClient(supabase, herd_id, email, herd_role_id, expires_at) {
-    const { data, error } = await supabase.rpc("create_herd_invitation", {
+export async function create_herd_invitation_query(client, herd_id, email, herd_role_id, expires_at) {
+    const { data, error } = await client.rpc("create_herd_invitation", {
         p_herd_id: herd_id,
         p_email: email,
         p_herd_role_id: herd_role_id,
@@ -11,25 +11,25 @@ export async function createHerdInvitationWithClient(supabase, herd_id, email, h
     }
     return IWebResponse.success(data).to_compatible();
 }
-export async function acceptHerdInvitationsWithClient(supabase, invitation_ids) {
+export async function accept_herd_invitations_for_current_user_query(client, invitation_ids) {
     if (invitation_ids.length === 0) {
         return IWebResponse.error("At least one invitation id is required").to_compatible();
     }
-    const { data, error } = await supabase.rpc("accept_herd_invitations_for_current_user", { p_invitation_ids: invitation_ids });
+    const { data, error } = await client.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();
 }
-export async function getHerdInvitationsForCurrentUserWithClient(supabase) {
-    const { data, error } = await supabase.rpc("get_herd_invitations_for_current_user");
+export async function get_herd_invitations_for_current_user_query(client) {
+    const { data, error } = await client.rpc("get_herd_invitations_for_current_user");
     if (error) {
         return IWebResponse.error(error.message).to_compatible();
     }
     return IWebResponse.success(data ?? []).to_compatible();
 }
-export async function getHerdInvitationsByHerdWithClient(supabase, herd_id) {
-    const { data, error } = await supabase
+export async function get_herd_invitations_by_herd_query(client, herd_id) {
+    const { data, error } = await client
         .from("herd_invitations")
         .select("*")
         .eq("herd_id", herd_id)
@@ -39,21 +39,21 @@ export async function getHerdInvitationsByHerdWithClient(supabase, herd_id) {
     }
     return IWebResponse.success(data ?? []).to_compatible();
 }
-export async function rejectHerdInvitationsWithClient(supabase, invitation_ids) {
+export async function reject_herd_invitations_for_current_user_query(client, invitation_ids) {
     if (invitation_ids.length === 0) {
         return IWebResponse.error("At least one invitation id is required").to_compatible();
     }
-    const { data, error } = await supabase.rpc("reject_herd_invitations_for_current_user", { p_invitation_ids: invitation_ids });
+    const { data, error } = await client.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();
 }
-export async function revokeHerdInvitationsWithClient(supabase, invitation_ids) {
+export async function revoke_herd_invitations_query(client, invitation_ids) {
     if (invitation_ids.length === 0) {
         return IWebResponse.error("At least one invitation id is required").to_compatible();
     }
-    const { data, error } = await supabase.rpc("revoke_herd_invitations", {
+    const { data, error } = await client.rpc("revoke_herd_invitations", {
         p_invitation_ids: invitation_ids,
     });
     if (error) {

package/dist/helpers/issuers.js

@@ -1,63 +1,17 @@
-"use server";
 import { newServerClient } from "../supabase/server";
-import { EnumWebResponse, IWebResponse, } from "../types/requests";
+import { create_issuer_query, get_issuer_by_id_query, get_issuers_by_localization_query, get_issuers_query, update_issuer_query, } from "./issuers.queries";
 export async function server_get_issuers() {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("issuers")
-        .select("*")
-        .order("name");
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
-    }
-    return IWebResponse.success(data ?? []).to_compatible();
+    return get_issuers_query(await newServerClient());
 }
 export async function server_get_issuer_by_id(issuer_id) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("issuers")
-        .select("*")
-        .eq("id", issuer_id)
-        .maybeSingle();
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
-    }
-    return IWebResponse.success(data).to_compatible();
+    return get_issuer_by_id_query(await newServerClient(), issuer_id);
 }
 export async function server_get_issuers_by_localization(localization_id) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("issuers")
-        .select("*")
-        .eq("localization_id", localization_id)
-        .order("name");
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
-    }
-    return IWebResponse.success(data ?? []).to_compatible();
+    return get_issuers_by_localization_query(await newServerClient(), localization_id);
 }
 export async function server_create_issuer(row) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("issuers")
-        .insert(row)
-        .select("*")
-        .single();
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
-    }
-    return IWebResponse.success(data).to_compatible();
+    return create_issuer_query(await newServerClient(), row);
 }
 export async function server_update_issuer(issuer_id, updates) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("issuers")
-        .update(updates)
-        .eq("id", issuer_id)
-        .select("*")
-        .single();
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
-    }
-    return IWebResponse.success(data).to_compatible();
+    return update_issuer_query(await newServerClient(), issuer_id, updates);
 }

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

@@ -0,0 +1,9 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { IIssuer, IssuerInsert, IssuerUpdate } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+import { Database } from "../types/supabase";
+export declare function get_issuers_query(client: SupabaseClient<Database>): Promise<IWebResponseCompatible<IIssuer[]>>;
+export declare function get_issuer_by_id_query(client: SupabaseClient<Database>, issuer_id: number): Promise<IWebResponseCompatible<IIssuer | null>>;
+export declare function get_issuers_by_localization_query(client: SupabaseClient<Database>, localization_id: number): Promise<IWebResponseCompatible<IIssuer[]>>;
+export declare function create_issuer_query(client: SupabaseClient<Database>, row: IssuerInsert): Promise<IWebResponseCompatible<IIssuer | null>>;
+export declare function update_issuer_query(client: SupabaseClient<Database>, issuer_id: number, updates: IssuerUpdate): Promise<IWebResponseCompatible<IIssuer | null>>;

package/dist/helpers/issuers.queries.js

@@ -0,0 +1,53 @@
+import { EnumWebResponse, IWebResponse, } from "../types/requests";
+export async function get_issuers_query(client) {
+    const { data, error } = await client.from("issuers").select("*").order("name");
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
+    }
+    return IWebResponse.success(data ?? []).to_compatible();
+}
+export async function get_issuer_by_id_query(client, issuer_id) {
+    const { data, error } = await client
+        .from("issuers")
+        .select("*")
+        .eq("id", issuer_id)
+        .maybeSingle();
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function get_issuers_by_localization_query(client, localization_id) {
+    const { data, error } = await client
+        .from("issuers")
+        .select("*")
+        .eq("localization_id", localization_id)
+        .order("name");
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
+    }
+    return IWebResponse.success(data ?? []).to_compatible();
+}
+export async function create_issuer_query(client, row) {
+    const { data, error } = await client
+        .from("issuers")
+        .insert(row)
+        .select("*")
+        .single();
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function update_issuer_query(client, issuer_id, updates) {
+    const { data, error } = await client
+        .from("issuers")
+        .update(updates)
+        .eq("id", issuer_id)
+        .select("*")
+        .single();
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    return IWebResponse.success(data).to_compatible();
+}

package/dist/helpers/layers.js

@@ -1,26 +1,8 @@
-"use server";
 import { newServerClient } from "../supabase/server";
-import { EnumWebResponse, IWebResponse, } from "../types/requests";
-import { get_layers_by_herd_ids_query } from "./herd_scoped.queries";
-// function that fetches the layers from our db given a herd id
+import { get_layers_by_herd_ids_query, get_layers_by_herd_query, } from "./layers.queries";
 export async function server_get_layers_by_herd(herd_id) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("layers")
-        .select("*")
-        .eq("herd_id", herd_id);
-    if (error) {
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: null,
-        };
-    }
-    else {
-        return IWebResponse.success(data).to_compatible();
-    }
+    return get_layers_by_herd_query(await newServerClient(), herd_id);
 }
-// Fetches layers for many herds in one query, grouped by herd_id.
 export async function server_get_layers_by_herd_ids(herd_ids) {
     return get_layers_by_herd_ids_query(await newServerClient(), herd_ids);
 }

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

@@ -2,4 +2,5 @@ import { SupabaseClient } from "@supabase/supabase-js";
 import { ILayer } from "../types/db";
 import { Database } from "../types/supabase";
 import { IWebResponseCompatible } from "../types/requests";
-export declare function get_layers_by_herd_ids_query(client: SupabaseClient<Database>, herd_ids: number[]): Promise<IWebResponseCompatible<Record<number, ILayer[]>>>;
+export { get_layers_by_herd_ids_query } from "./herd_scoped.queries";
+export declare function get_layers_by_herd_query(client: SupabaseClient<Database>, herd_id: number): Promise<IWebResponseCompatible<ILayer[]>>;