@adventurelabs/scout-core 1.5.5 → 2.0.1

package/dist/helpers/parts_server.js

@@ -0,0 +1,71 @@
+import { newServerClient } from "../supabase/server";
+import { create_part, delete_part, get_deleted_parts_by_device_id, get_part_by_id, get_parts_by_certificate_id, get_parts_by_device_id, get_parts_by_herd_id, get_parts_by_herd_ids, get_parts_by_lifecycle, get_parts_by_product_and_serial, get_parts_by_product_number, get_parts_by_serial_number, get_parts_by_status, hard_delete_part, restore_part, update_part, update_part_status, } from "./parts";
+export async function server_get_parts_by_device_id(device_id) {
+    const client = await newServerClient();
+    return get_parts_by_device_id(client, device_id);
+}
+export async function server_get_part_by_id(part_id) {
+    const client = await newServerClient();
+    return get_part_by_id(client, part_id);
+}
+export async function server_get_parts_by_serial_number(serial_number) {
+    const client = await newServerClient();
+    return get_parts_by_serial_number(client, serial_number);
+}
+export async function server_get_parts_by_product_number(product_number) {
+    const client = await newServerClient();
+    return get_parts_by_product_number(client, product_number);
+}
+export async function server_get_parts_by_lifecycle(lifecycle) {
+    const client = await newServerClient();
+    return get_parts_by_lifecycle(client, lifecycle);
+}
+/** @deprecated Use server_get_parts_by_lifecycle */
+export async function server_get_parts_by_status(lifecycle) {
+    const client = await newServerClient();
+    return get_parts_by_status(client, lifecycle);
+}
+export async function server_create_part(newPart) {
+    const client = await newServerClient();
+    return create_part(client, newPart);
+}
+export async function server_update_part(part_id, updatedPart) {
+    const client = await newServerClient();
+    return update_part(client, part_id, updatedPart);
+}
+export async function server_delete_part(part_id, options) {
+    const client = await newServerClient();
+    return delete_part(client, part_id, options);
+}
+export async function server_update_part_status(part_id, lifecycle, options) {
+    const client = await newServerClient();
+    return update_part_status(client, part_id, lifecycle, options);
+}
+export async function server_get_parts_by_certificate_id(certificate_id) {
+    const client = await newServerClient();
+    return get_parts_by_certificate_id(client, certificate_id);
+}
+export async function server_get_parts_by_herd_id(herd_id) {
+    const client = await newServerClient();
+    return get_parts_by_herd_id(client, herd_id);
+}
+export async function server_get_parts_by_herd_ids(herd_ids) {
+    const client = await newServerClient();
+    return get_parts_by_herd_ids(client, herd_ids);
+}
+export async function server_restore_part(part_id, options) {
+    const client = await newServerClient();
+    return restore_part(client, part_id, options);
+}
+export async function server_hard_delete_part(part_id) {
+    const client = await newServerClient();
+    return hard_delete_part(client, part_id);
+}
+export async function server_get_deleted_parts_by_device_id(device_id) {
+    const client = await newServerClient();
+    return get_deleted_parts_by_device_id(client, device_id);
+}
+export async function server_get_parts_by_product_and_serial(product_number, serial_number) {
+    const client = await newServerClient();
+    return get_parts_by_product_and_serial(client, product_number, serial_number);
+}

package/dist/helpers/pins_server.d.ts

@@ -0,0 +1,118 @@
+import { PinInsert } from "../types/db";
+export declare function server_get_pins_for_herd(herd_id: number): Promise<import("../types").IWebResponseCompatible<{
+    id: number | null;
+    created_at: string | null;
+    location: unknown;
+    altitude_relative_to_ground: number | null;
+    color: string | null;
+    name: string | null;
+    description: string | null;
+    herd_id: number | null;
+    created_by: string | null;
+    latitude: number | null;
+    longitude: number | null;
+}[]>>;
+export declare function server_get_pin_by_id(pin_id: number): Promise<import("../types").IWebResponseCompatible<{
+    id: number | null;
+    created_at: string | null;
+    location: unknown;
+    altitude_relative_to_ground: number | null;
+    color: string | null;
+    name: string | null;
+    description: string | null;
+    herd_id: number | null;
+    created_by: string | null;
+    latitude: number | null;
+    longitude: number | null;
+} | null>>;
+export declare function server_create_pin(newPin: PinInsert): Promise<import("../types").IWebResponseCompatible<{
+    id: number | null;
+    created_at: string | null;
+    location: unknown;
+    altitude_relative_to_ground: number | null;
+    color: string | null;
+    name: string | null;
+    description: string | null;
+    herd_id: number | null;
+    created_by: string | null;
+    latitude: number | null;
+    longitude: number | null;
+} | null>>;
+export declare function server_create_pin_with_coordinates(latitude: number, longitude: number, pinData: Omit<PinInsert, "location">): Promise<import("../types").IWebResponseCompatible<{
+    id: number | null;
+    created_at: string | null;
+    location: unknown;
+    altitude_relative_to_ground: number | null;
+    color: string | null;
+    name: string | null;
+    description: string | null;
+    herd_id: number | null;
+    created_by: string | null;
+    latitude: number | null;
+    longitude: number | null;
+} | null>>;
+export declare function server_update_pin(pin_id: number, updatedPin: Partial<PinInsert>): Promise<import("../types").IWebResponseCompatible<{
+    id: number | null;
+    created_at: string | null;
+    location: unknown;
+    altitude_relative_to_ground: number | null;
+    color: string | null;
+    name: string | null;
+    description: string | null;
+    herd_id: number | null;
+    created_by: string | null;
+    latitude: number | null;
+    longitude: number | null;
+} | null>>;
+export declare function server_update_pin_location(pin_id: number, latitude: number, longitude: number, updatedPin?: Partial<Omit<PinInsert, "location">>): Promise<import("../types").IWebResponseCompatible<{
+    id: number | null;
+    created_at: string | null;
+    location: unknown;
+    altitude_relative_to_ground: number | null;
+    color: string | null;
+    name: string | null;
+    description: string | null;
+    herd_id: number | null;
+    created_by: string | null;
+    latitude: number | null;
+    longitude: number | null;
+} | null>>;
+export declare function server_delete_pin(pin_id: number): Promise<import("../types").IWebResponseCompatible<{
+    id: number | null;
+    created_at: string | null;
+    location: unknown;
+    altitude_relative_to_ground: number | null;
+    color: string | null;
+    name: string | null;
+    description: string | null;
+    herd_id: number | null;
+    created_by: string | null;
+    latitude: number | null;
+    longitude: number | null;
+} | null>>;
+export declare function server_get_pins_by_created_by(user_id: string): Promise<import("../types").IWebResponseCompatible<{
+    id: number | null;
+    created_at: string | null;
+    location: unknown;
+    altitude_relative_to_ground: number | null;
+    color: string | null;
+    name: string | null;
+    description: string | null;
+    herd_id: number | null;
+    created_by: string | null;
+    latitude: number | null;
+    longitude: number | null;
+}[]>>;
+export declare function server_get_pins_by_color(herd_id: number, color: string): Promise<import("../types").IWebResponseCompatible<{
+    id: number | null;
+    created_at: string | null;
+    location: unknown;
+    altitude_relative_to_ground: number | null;
+    color: string | null;
+    name: string | null;
+    description: string | null;
+    herd_id: number | null;
+    created_by: string | null;
+    latitude: number | null;
+    longitude: number | null;
+}[]>>;

package/dist/helpers/pins_server.js

@@ -0,0 +1,38 @@
+import { newServerClient } from "../supabase/server";
+import { create_pin, create_pin_with_coordinates, delete_pin, get_pin_by_id, get_pins_by_color, get_pins_by_created_by, get_pins_for_herd, update_pin, update_pin_location, } from "./pins";
+export async function server_get_pins_for_herd(herd_id) {
+    const client = await newServerClient();
+    return get_pins_for_herd(client, herd_id);
+}
+export async function server_get_pin_by_id(pin_id) {
+    const client = await newServerClient();
+    return get_pin_by_id(client, pin_id);
+}
+export async function server_create_pin(newPin) {
+    const client = await newServerClient();
+    return create_pin(client, newPin);
+}
+export async function server_create_pin_with_coordinates(latitude, longitude, pinData) {
+    const client = await newServerClient();
+    return create_pin_with_coordinates(client, latitude, longitude, pinData);
+}
+export async function server_update_pin(pin_id, updatedPin) {
+    const client = await newServerClient();
+    return update_pin(client, pin_id, updatedPin);
+}
+export async function server_update_pin_location(pin_id, latitude, longitude, updatedPin) {
+    const client = await newServerClient();
+    return update_pin_location(client, pin_id, latitude, longitude, updatedPin);
+}
+export async function server_delete_pin(pin_id) {
+    const client = await newServerClient();
+    return delete_pin(client, pin_id);
+}
+export async function server_get_pins_by_created_by(user_id) {
+    const client = await newServerClient();
+    return get_pins_by_created_by(client, user_id);
+}
+export async function server_get_pins_by_color(herd_id, color) {
+    const client = await newServerClient();
+    return get_pins_by_color(client, herd_id, color);
+}

package/dist/helpers/plans.js

@@ -1,66 +1,14 @@
-"use server";
 import { newServerClient } from "../supabase/server";
-import { EnumWebResponse, IWebResponse, } from "../types/requests";
-import { get_plans_by_herd_ids_query } from "./herd_scoped.queries";
-// function that fetches the plans our db given a herd id
+import { create_plans_query, delete_plans_by_ids_query, get_plans_by_herd_ids_query, get_plans_by_herd_query, } from "./plans.queries";
 export async function server_get_plans_by_herd(herd_id) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("plans")
-        .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_plans_by_herd_query(await newServerClient(), herd_id);
 }
-// Fetches plans for many herds in one query, grouped by herd_id.
 export async function server_get_plans_by_herd_ids(herd_ids) {
     return get_plans_by_herd_ids_query(await newServerClient(), herd_ids);
 }
-// function that uploads plan to our db
 export async function server_create_plans(plans) {
-    // loop through plans and format
-    let formatted_plans = plans.map((plan) => {
-        let formatted_plan = { ...plan };
-        delete formatted_plan.id;
-        delete formatted_plan.inserted_at;
-        return formatted_plan;
-    });
-    const supabase = await newServerClient();
-    // insert data and return the response
-    const { data, error } = await supabase
-        .from("plans")
-        .insert(formatted_plans)
-        .select("*");
-    if (error) {
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: null,
-        };
-    }
-    else {
-        return IWebResponse.success(data).to_compatible();
-    }
+    return create_plans_query(await newServerClient(), plans);
 }
 export async function server_delete_plans_by_ids(plan_ids) {
-    const supabase = await newServerClient();
-    const { error } = await supabase.from("plans").delete().in("id", plan_ids);
-    if (error) {
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: false,
-        };
-    }
-    else {
-        return IWebResponse.success(true).to_compatible();
-    }
+    return delete_plans_by_ids_query(await newServerClient(), plan_ids);
 }

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

@@ -2,4 +2,7 @@ import { SupabaseClient } from "@supabase/supabase-js";
 import { IPlan } from "../types/db";
 import { Database } from "../types/supabase";
 import { IWebResponseCompatible } from "../types/requests";
-export declare function get_plans_by_herd_ids_query(client: SupabaseClient<Database>, herd_ids: number[]): Promise<IWebResponseCompatible<Record<number, IPlan[]>>>;
+export { get_plans_by_herd_ids_query } from "./herd_scoped.queries";
+export declare function get_plans_by_herd_query(client: SupabaseClient<Database>, herd_id: number): Promise<IWebResponseCompatible<IPlan[]>>;
+export declare function create_plans_query(client: SupabaseClient<Database>, plans: IPlan[]): Promise<IWebResponseCompatible<IPlan[]>>;
+export declare function delete_plans_by_ids_query(client: SupabaseClient<Database>, plan_ids: number[]): Promise<IWebResponseCompatible<boolean>>;

package/dist/helpers/plans.queries.js

@@ -1,20 +1,47 @@
 import { EnumWebResponse, IWebResponse, } from "../types/requests";
-export async function get_plans_by_herd_ids_query(client, herd_ids) {
-    var _a;
-    if (herd_ids.length === 0) {
-        return IWebResponse.success({}).to_compatible();
-    }
+export { get_plans_by_herd_ids_query } from "./herd_scoped.queries";
+export async function get_plans_by_herd_query(client, herd_id) {
     const { data, error } = await client
         .from("plans")
         .select("*")
-        .in("herd_id", herd_ids)
-        .order("id", { ascending: true });
+        .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_plans_query(client, plans) {
+    const formatted_plans = plans.map(({ herd_id, instructions, name, plan_type }) => ({
+        herd_id,
+        instructions,
+        name,
+        plan_type,
+    }));
+    const { data, error } = await client
+        .from("plans")
+        .insert(formatted_plans)
+        .select("*");
     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_plans_by_ids_query(client, plan_ids) {
+    const { error } = await client.from("plans").delete().in("id", plan_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/points_for_user_server.d.ts

@@ -0,0 +1,9 @@
+export declare function server_get_points_for_user_by_user_id(user_id: string): Promise<import("../types").IWebResponseCompatible<{
+    id: number;
+    inserted_at: string;
+    points: number;
+    update_reason: string;
+    user_id: string;
+}[]>>;
+export declare function server_get_points_balance_for_user_id(user_id: string): Promise<import("../types").IWebResponseCompatible<number>>;
+export declare function server_update_points_balance_for_user(user_id: string, balance: number, update_reason: string): Promise<import("../types").IWebResponseCompatible<import("./points_for_user").PointsBalanceUpdateResult | null>>;

package/dist/helpers/points_for_user_server.js

@@ -0,0 +1,14 @@
+import { newServerClient } from "../supabase/server";
+import { get_points_balance_for_user_id, get_points_for_user_by_user_id, update_points_balance_for_user, } from "./points_for_user";
+export async function server_get_points_for_user_by_user_id(user_id) {
+    const client = await newServerClient();
+    return get_points_for_user_by_user_id(client, user_id);
+}
+export async function server_get_points_balance_for_user_id(user_id) {
+    const client = await newServerClient();
+    return get_points_balance_for_user_id(client, user_id);
+}
+export async function server_update_points_balance_for_user(user_id, balance, update_reason) {
+    const client = await newServerClient();
+    return update_points_balance_for_user(client, user_id, balance, update_reason);
+}

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!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 supabase
-        .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();
+    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!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();
+    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);
 }