@adventurelabs/scout-core 1.5.4 → 2.0.0

package/dist/helpers/product_compatibilities.js

@@ -1,89 +1,17 @@
-"use server";
 import { newServerClient } from "../supabase/server";
-import { EnumWebResponse, IWebResponse, } from "../types/requests";
+import { create_product_compatibility_query, delete_product_compatibility_query, get_auto_assign_accessory_product_number_query, get_product_compatibilities_query, update_product_compatibility_query, } from "./product_compatibilities.queries";
 export async function server_get_product_compatibilities(primary_product_number, role) {
-    const supabase = await newServerClient();
-    const { data: primary, error: primaryError } = await supabase
-        .from("product_numbers")
-        .select("product_id, products!inner(manufacturers!inner(id))")
-        .eq("product_number", primary_product_number)
-        .eq("lifecycle", "active")
-        .eq("products.lifecycle", "active")
-        .eq("products.manufacturers.lifecycle", "active")
-        .maybeSingle();
-    if (primaryError) {
-        return IWebResponse.error(primaryError.message).to_compatible();
-    }
-    if (!primary) {
-        return IWebResponse.success([]).to_compatible();
-    }
-    const { data, error } = await supabase
-        .from("product_compatibilities")
-        .select("*, product_numbers!product_compatibilities_accessory_product_number_fkey!inner(products!inner(manufacturers!inner(id)))")
-        .eq("primary_product_id", primary.product_id)
-        .eq("role", role)
-        .eq("product_numbers.lifecycle", "active")
-        .eq("product_numbers.products.lifecycle", "active")
-        .eq("product_numbers.products.manufacturers.lifecycle", "active")
-        .order("accessory_product_number");
-    if (error) {
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    const compatibilities = (data ?? []).map(({ primary_product_id, role, accessory_product_number, auto_assign, inserted_at, }) => ({
-        primary_product_id,
-        role,
-        accessory_product_number,
-        auto_assign,
-        inserted_at,
-    }));
-    return IWebResponse.success(compatibilities).to_compatible();
+    return get_product_compatibilities_query(await newServerClient(), primary_product_number, role);
 }
 export async function server_get_auto_assign_accessory_product_number(primary_product_number, role) {
-    const response = await server_get_product_compatibilities(primary_product_number, role);
-    if (response.status !== EnumWebResponse.SUCCESS) {
-        return IWebResponse.error(response.msg ?? "Unable to load product compatibilities").to_compatible();
-    }
-    const productNumber = response.data?.find((compatibility) => compatibility.auto_assign)
-        ?.accessory_product_number ?? null;
-    return IWebResponse.success(productNumber).to_compatible();
+    return get_auto_assign_accessory_product_number_query(await newServerClient(), primary_product_number, role);
 }
 export async function server_create_product_compatibility(compatibility) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("product_compatibilities")
-        .insert(compatibility)
-        .select("*")
-        .single();
-    if (error) {
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    return IWebResponse.success(data).to_compatible();
+    return create_product_compatibility_query(await newServerClient(), compatibility);
 }
 export async function server_update_product_compatibility(primary_product_id, role, accessory_product_number, updates) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("product_compatibilities")
-        .update(updates)
-        .eq("primary_product_id", primary_product_id)
-        .eq("role", role)
-        .eq("accessory_product_number", accessory_product_number)
-        .select("*")
-        .single();
-    if (error) {
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    return IWebResponse.success(data).to_compatible();
+    return update_product_compatibility_query(await newServerClient(), primary_product_id, role, accessory_product_number, updates);
 }
 export async function server_delete_product_compatibility(primary_product_id, role, accessory_product_number) {
-    const supabase = await newServerClient();
-    const { error } = await supabase
-        .from("product_compatibilities")
-        .delete()
-        .eq("primary_product_id", primary_product_id)
-        .eq("role", role)
-        .eq("accessory_product_number", accessory_product_number);
-    if (error) {
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    return IWebResponse.success(true).to_compatible();
+    return delete_product_compatibility_query(await newServerClient(), primary_product_id, role, accessory_product_number);
 }

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

@@ -0,0 +1,9 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { IProductCompatibility, ProductCompatibilityInsert, ProductCompatibilityUpdate } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+import { Database } from "../types/supabase";
+export declare function get_product_compatibilities_query(client: SupabaseClient<Database>, primary_product_number: string, role: string): Promise<IWebResponseCompatible<IProductCompatibility[]>>;
+export declare function get_auto_assign_accessory_product_number_query(client: SupabaseClient<Database>, primary_product_number: string, role: string): Promise<IWebResponseCompatible<string | null>>;
+export declare function create_product_compatibility_query(client: SupabaseClient<Database>, compatibility: ProductCompatibilityInsert): Promise<IWebResponseCompatible<IProductCompatibility | null>>;
+export declare function update_product_compatibility_query(client: SupabaseClient<Database>, primary_product_id: number, role: string, accessory_product_number: string, updates: ProductCompatibilityUpdate): Promise<IWebResponseCompatible<IProductCompatibility | null>>;
+export declare function delete_product_compatibility_query(client: SupabaseClient<Database>, primary_product_id: number, role: string, accessory_product_number: string): Promise<IWebResponseCompatible<boolean>>;

package/dist/helpers/product_compatibilities.queries.js

@@ -0,0 +1,83 @@
+import { EnumWebResponse, IWebResponse, } from "../types/requests";
+export async function get_product_compatibilities_query(client, primary_product_number, role) {
+    const { data: primary, error: primaryError } = await client
+        .from("product_numbers")
+        .select("product_id, products!product_numbers_product_id_fkey!inner(manufacturers!inner(id))")
+        .eq("product_number", primary_product_number)
+        .eq("lifecycle", "active")
+        .eq("products.lifecycle", "active")
+        .eq("products.manufacturers.lifecycle", "active")
+        .maybeSingle();
+    if (primaryError) {
+        return IWebResponse.error(primaryError.message).to_compatible();
+    }
+    if (!primary) {
+        return IWebResponse.success([]).to_compatible();
+    }
+    const { data, error } = await client
+        .from("product_compatibilities")
+        .select("*, product_numbers!product_compatibilities_accessory_product_number_fkey!inner(products!product_numbers_product_id_fkey!inner(manufacturers!inner(id)))")
+        .eq("primary_product_id", primary.product_id)
+        .eq("role", role)
+        .eq("product_numbers.lifecycle", "active")
+        .eq("product_numbers.products.lifecycle", "active")
+        .eq("product_numbers.products.manufacturers.lifecycle", "active")
+        .order("accessory_product_number");
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    const compatibilities = (data ?? []).map(({ primary_product_id, role, accessory_product_number, auto_assign, inserted_at, }) => ({
+        primary_product_id,
+        role,
+        accessory_product_number,
+        auto_assign,
+        inserted_at,
+    }));
+    return IWebResponse.success(compatibilities).to_compatible();
+}
+export async function get_auto_assign_accessory_product_number_query(client, primary_product_number, role) {
+    const response = await get_product_compatibilities_query(client, primary_product_number, role);
+    if (response.status !== EnumWebResponse.SUCCESS) {
+        return IWebResponse.error(response.msg ?? "Unable to load product compatibilities").to_compatible();
+    }
+    const productNumber = response.data?.find((compatibility) => compatibility.auto_assign)
+        ?.accessory_product_number ?? null;
+    return IWebResponse.success(productNumber).to_compatible();
+}
+export async function create_product_compatibility_query(client, compatibility) {
+    const { data, error } = await client
+        .from("product_compatibilities")
+        .insert(compatibility)
+        .select("*")
+        .single();
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function update_product_compatibility_query(client, primary_product_id, role, accessory_product_number, updates) {
+    const { data, error } = await client
+        .from("product_compatibilities")
+        .update(updates)
+        .eq("primary_product_id", primary_product_id)
+        .eq("role", role)
+        .eq("accessory_product_number", accessory_product_number)
+        .select("*")
+        .single();
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function delete_product_compatibility_query(client, primary_product_id, role, accessory_product_number) {
+    const { error } = await client
+        .from("product_compatibilities")
+        .delete()
+        .eq("primary_product_id", primary_product_id)
+        .eq("role", role)
+        .eq("accessory_product_number", accessory_product_number);
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    return IWebResponse.success(true).to_compatible();
+}

package/dist/helpers/product_numbers.js

@@ -1,66 +1,17 @@
-"use server";
 import { newServerClient } from "../supabase/server";
-import { EnumWebResponse, IWebResponse, } from "../types/requests";
+import { create_product_number_query, get_product_for_product_number_query, get_product_number_query, get_product_numbers_by_product_query, update_product_number_query, } from "./product_numbers.queries";
 export async function server_get_product_numbers_by_product(product_id) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("product_numbers")
-        .select("*")
-        .eq("product_id", product_id)
-        .order("product_number");
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
-    }
-    return IWebResponse.success(data ?? []).to_compatible();
+    return get_product_numbers_by_product_query(await newServerClient(), product_id);
 }
 export async function server_get_product_number(product_number) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("product_numbers")
-        .select("*")
-        .eq("product_number", product_number)
-        .maybeSingle();
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
-    }
-    return IWebResponse.success(data).to_compatible();
+    return get_product_number_query(await newServerClient(), product_number);
 }
-// Resolves the product line for a given product_number via the FK chain.
 export async function server_get_product_for_product_number(product_number) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("product_numbers")
-        .select("products(*)")
-        .eq("product_number", product_number)
-        .maybeSingle();
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
-    }
-    const product = data?.products ?? null;
-    return IWebResponse.success(product).to_compatible();
+    return get_product_for_product_number_query(await newServerClient(), product_number);
 }
 export async function server_create_product_number(row) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("product_numbers")
-        .insert(row)
-        .select("*")
-        .single();
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
-    }
-    return IWebResponse.success(data).to_compatible();
+    return create_product_number_query(await newServerClient(), row);
 }
 export async function server_update_product_number(product_number, updates) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("product_numbers")
-        .update(updates)
-        .eq("product_number", product_number)
-        .select("*")
-        .single();
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
-    }
-    return IWebResponse.success(data).to_compatible();
+    return update_product_number_query(await newServerClient(), product_number, updates);
 }

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

@@ -0,0 +1,9 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { IProduct, IProductNumber, ProductNumberInsert, ProductNumberUpdate } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+import { Database } from "../types/supabase";
+export declare function get_product_numbers_by_product_query(client: SupabaseClient<Database>, product_id: number): Promise<IWebResponseCompatible<IProductNumber[]>>;
+export declare function get_product_number_query(client: SupabaseClient<Database>, product_number: string): Promise<IWebResponseCompatible<IProductNumber | null>>;
+export declare function get_product_for_product_number_query(client: SupabaseClient<Database>, product_number: string): Promise<IWebResponseCompatible<IProduct | null>>;
+export declare function create_product_number_query(client: SupabaseClient<Database>, row: ProductNumberInsert): Promise<IWebResponseCompatible<IProductNumber | null>>;
+export declare function update_product_number_query(client: SupabaseClient<Database>, product_number: string, updates: ProductNumberUpdate): Promise<IWebResponseCompatible<IProductNumber | null>>;

package/dist/helpers/product_numbers.queries.js

@@ -0,0 +1,58 @@
+import { EnumWebResponse, IWebResponse, } from "../types/requests";
+export async function get_product_numbers_by_product_query(client, product_id) {
+    const { data, error } = await client
+        .from("product_numbers")
+        .select("*")
+        .eq("product_id", product_id)
+        .order("product_number");
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
+    }
+    return IWebResponse.success(data ?? []).to_compatible();
+}
+export async function get_product_number_query(client, product_number) {
+    const { data, error } = await client
+        .from("product_numbers")
+        .select("*")
+        .eq("product_number", product_number)
+        .maybeSingle();
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function get_product_for_product_number_query(client, product_number) {
+    const { data, error } = await client
+        .from("product_numbers")
+        .select("products!product_numbers_product_id_fkey(*)")
+        .eq("product_number", product_number)
+        .maybeSingle();
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    const product = data?.products ?? null;
+    return IWebResponse.success(product).to_compatible();
+}
+export async function create_product_number_query(client, row) {
+    const { data, error } = await client
+        .from("product_numbers")
+        .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_product_number_query(client, product_number, updates) {
+    const { data, error } = await client
+        .from("product_numbers")
+        .update(updates)
+        .eq("product_number", product_number)
+        .select("*")
+        .single();
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    return IWebResponse.success(data).to_compatible();
+}

package/dist/helpers/products.js

@@ -1,65 +1,17 @@
-"use server";
 import { newServerClient } from "../supabase/server";
-import { EnumWebResponse, IWebResponse, } from "../types/requests";
+import { create_product_query, get_product_by_id_query, get_products_by_manufacturer_query, get_products_query, update_product_query, } from "./products.queries";
 export async function server_get_products(options) {
-    const supabase = await newServerClient();
-    let query = supabase.from("products").select("*").order("name");
-    if (!options?.include_inactive) {
-        query = query.eq("lifecycle", "active");
-    }
-    const { data, error } = await query;
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
-    }
-    return IWebResponse.success(data ?? []).to_compatible();
+    return get_products_query(await newServerClient(), options);
 }
 export async function server_get_product_by_id(product_id) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("products")
-        .select("*")
-        .eq("id", product_id)
-        .maybeSingle();
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
-    }
-    return IWebResponse.success(data).to_compatible();
+    return get_product_by_id_query(await newServerClient(), product_id);
 }
 export async function server_get_products_by_manufacturer(manufacturer_id) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("products")
-        .select("*")
-        .eq("manufacturer_id", manufacturer_id)
-        .eq("lifecycle", "active")
-        .order("name");
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
-    }
-    return IWebResponse.success(data ?? []).to_compatible();
+    return get_products_by_manufacturer_query(await newServerClient(), manufacturer_id);
 }
 export async function server_create_product(row) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("products")
-        .insert(row)
-        .select("*")
-        .single();
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
-    }
-    return IWebResponse.success(data).to_compatible();
+    return create_product_query(await newServerClient(), row);
 }
 export async function server_update_product(product_id, updates) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("products")
-        .update(updates)
-        .eq("id", product_id)
-        .select("*")
-        .single();
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
-    }
-    return IWebResponse.success(data).to_compatible();
+    return update_product_query(await newServerClient(), product_id, updates);
 }

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

@@ -0,0 +1,11 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { IProduct, ProductInsert, ProductUpdate } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+import { Database } from "../types/supabase";
+export declare function get_products_query(client: SupabaseClient<Database>, options?: {
+    include_inactive?: boolean;
+}): Promise<IWebResponseCompatible<IProduct[]>>;
+export declare function get_product_by_id_query(client: SupabaseClient<Database>, product_id: number): Promise<IWebResponseCompatible<IProduct | null>>;
+export declare function get_products_by_manufacturer_query(client: SupabaseClient<Database>, manufacturer_id: number): Promise<IWebResponseCompatible<IProduct[]>>;
+export declare function create_product_query(client: SupabaseClient<Database>, row: ProductInsert): Promise<IWebResponseCompatible<IProduct | null>>;
+export declare function update_product_query(client: SupabaseClient<Database>, product_id: number, updates: ProductUpdate): Promise<IWebResponseCompatible<IProduct | null>>;

package/dist/helpers/products.queries.js

@@ -0,0 +1,58 @@
+import { EnumWebResponse, IWebResponse, } from "../types/requests";
+export async function get_products_query(client, options) {
+    let query = client.from("products").select("*").order("name");
+    if (!options?.include_inactive) {
+        query = query.eq("lifecycle", "active");
+    }
+    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_product_by_id_query(client, product_id) {
+    const { data, error } = await client
+        .from("products")
+        .select("*")
+        .eq("id", product_id)
+        .maybeSingle();
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function get_products_by_manufacturer_query(client, manufacturer_id) {
+    const { data, error } = await client
+        .from("products")
+        .select("*")
+        .eq("manufacturer_id", manufacturer_id)
+        .eq("lifecycle", "active")
+        .order("name");
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
+    }
+    return IWebResponse.success(data ?? []).to_compatible();
+}
+export async function create_product_query(client, row) {
+    const { data, error } = await client
+        .from("products")
+        .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_product_query(client, product_id, updates) {
+    const { data, error } = await client
+        .from("products")
+        .update(updates)
+        .eq("id", product_id)
+        .select("*")
+        .single();
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    return IWebResponse.success(data).to_compatible();
+}

package/dist/helpers/providers.js

@@ -1,83 +1,17 @@
-"use server";
 import { newServerClient } from "../supabase/server";
-import { EnumWebResponse, IWebResponse, } from "../types/requests";
-import { get_providers_by_herd_ids_query } from "./herd_scoped.queries";
-// function that fetches the providers from our db given a herd id
+import { create_provider_query, delete_providers_by_ids_query, get_providers_by_herd_ids_query, get_providers_by_herd_query, update_provider_query, } from "./providers.queries";
 export async function server_get_providers_by_herd(herd_id) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("providers")
-        .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_providers_by_herd_query(await newServerClient(), herd_id);
 }
-// Fetches providers for many herds in one query, grouped by herd_id.
 export async function server_get_providers_by_herd_ids(herd_ids) {
     return get_providers_by_herd_ids_query(await newServerClient(), herd_ids);
 }
-// function that creates a new provider in our db
 export async function server_create_provider(provider) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("providers")
-        .insert(provider)
-        .select("*")
-        .single();
-    if (error) {
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: null,
-        };
-    }
-    else {
-        return IWebResponse.success(data).to_compatible();
-    }
+    return create_provider_query(await newServerClient(), provider);
 }
-// function that updates a provider in our db
 export async function server_update_provider(provider_id, updates) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("providers")
-        .update(updates)
-        .eq("id", provider_id)
-        .select("*")
-        .single();
-    if (error) {
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: null,
-        };
-    }
-    else {
-        return IWebResponse.success(data).to_compatible();
-    }
+    return update_provider_query(await newServerClient(), provider_id, updates);
 }
-// function that deletes providers by ids
 export async function server_delete_providers_by_ids(provider_ids) {
-    const supabase = await newServerClient();
-    const { error } = await supabase
-        .from("providers")
-        .delete()
-        .in("id", provider_ids);
-    if (error) {
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: false,
-        };
-    }
-    else {
-        return IWebResponse.success(true).to_compatible();
-    }
+    return delete_providers_by_ids_query(await newServerClient(), provider_ids);
 }

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

@@ -2,4 +2,8 @@ import { SupabaseClient } from "@supabase/supabase-js";
 import { IProvider } from "../types/db";
 import { Database } from "../types/supabase";
 import { IWebResponseCompatible } from "../types/requests";
-export declare function get_providers_by_herd_ids_query(client: SupabaseClient<Database>, herd_ids: number[]): Promise<IWebResponseCompatible<Record<number, IProvider[]>>>;
+export { get_providers_by_herd_ids_query } from "./herd_scoped.queries";
+export declare function get_providers_by_herd_query(client: SupabaseClient<Database>, herd_id: number): Promise<IWebResponseCompatible<IProvider[]>>;
+export declare function create_provider_query(client: SupabaseClient<Database>, provider: Omit<IProvider, "id" | "created_at">): Promise<IWebResponseCompatible<IProvider>>;
+export declare function update_provider_query(client: SupabaseClient<Database>, provider_id: number, updates: Partial<Omit<IProvider, "id" | "created_at">>): Promise<IWebResponseCompatible<IProvider>>;
+export declare function delete_providers_by_ids_query(client: SupabaseClient<Database>, provider_ids: number[]): Promise<IWebResponseCompatible<boolean>>;

package/dist/helpers/providers.queries.js

@@ -1,20 +1,61 @@
 import { EnumWebResponse, IWebResponse, } from "../types/requests";
-export async function get_providers_by_herd_ids_query(client, herd_ids) {
-    var _a;
-    if (herd_ids.length === 0) {
-        return IWebResponse.success({}).to_compatible();
+export { get_providers_by_herd_ids_query } from "./herd_scoped.queries";
+export async function get_providers_by_herd_query(client, herd_id) {
+    const { data, error } = await client
+        .from("providers")
+        .select("*")
+        .eq("herd_id", herd_id);
+    if (error) {
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: null,
+        };
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function create_provider_query(client, provider) {
+    const { data, error } = await client
+        .from("providers")
+        .insert(provider)
+        .select("*")
+        .single();
+    if (error) {
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: null,
+        };
     }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function update_provider_query(client, provider_id, updates) {
     const { data, error } = await client
         .from("providers")
+        .update(updates)
+        .eq("id", provider_id)
         .select("*")
-        .in("herd_id", herd_ids)
-        .order("id", { ascending: true });
+        .single();
     if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: null,
+        };
     }
-    const grouped = {};
-    for (const row of data ?? []) {
-        (grouped[_a = row.herd_id] ?? (grouped[_a] = [])).push(row);
+    return IWebResponse.success(data).to_compatible();
+}
+export async function delete_providers_by_ids_query(client, provider_ids) {
+    const { error } = await client
+        .from("providers")
+        .delete()
+        .in("id", provider_ids);
+    if (error) {
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: false,
+        };
     }
-    return IWebResponse.success(grouped).to_compatible();
+    return IWebResponse.success(true).to_compatible();
 }

package/dist/helpers/pubsub_token_server.d.ts

@@ -1,3 +1,4 @@
 import { IPubsubTokenMint } from "../types/pubsub_token";
 import { IWebResponseCompatible } from "../types/requests";
 export declare function server_mint_pubsub_token(): Promise<IWebResponseCompatible<IPubsubTokenMint>>;
+export declare function server_get_pubsub_jwt_public_keys(): Promise<IWebResponseCompatible<import("../types").IPubsubJwtPublicKeyEntry[]>>;