@adventurelabs/scout-core 1.5.4 → 2.0.0

package/dist/helpers/operating_contexts.queries.js

@@ -0,0 +1,223 @@
+import { IWebResponse } from "../types/requests";
+function error(message) {
+    return IWebResponse.error(message).to_compatible();
+}
+function page_limit(options) {
+    const limit = options?.limit ?? 100;
+    return limit < 1 || limit > 500 ? null : limit;
+}
+async function authenticated_user_id(client) {
+    const { data, error: authError } = await client.auth.getUser();
+    return authError ? null : (data.user?.id ?? null);
+}
+function with_lifecycle_actor(updates, user_id) {
+    return updates.lifecycle
+        ? { ...updates, lifecycle_changed_by: user_id }
+        : updates;
+}
+function with_update_actor(updates, user_id) {
+    return { ...with_lifecycle_actor(updates, user_id), updated_by: user_id };
+}
+function update_error(updates) {
+    if (Object.keys(updates).length === 0)
+        return "no fields to update";
+    if (updates.lifecycle_reason !== undefined && updates.lifecycle === undefined) {
+        return "lifecycle_reason requires lifecycle";
+    }
+    return null;
+}
+async function list_by(client, table, column, value, options) {
+    const limit = page_limit(options);
+    if (limit == null)
+        return error("limit must be between 1 and 500");
+    let query = client
+        .from(table)
+        .select("*")
+        .eq(column, value)
+        .order("id")
+        .limit(limit);
+    if (!options?.include_inactive)
+        query = query.eq("lifecycle", "active");
+    if (options?.after_id != null)
+        query = query.gt("id", options.after_id);
+    const { data, error: queryError } = await query;
+    return queryError
+        ? error(queryError.message)
+        : IWebResponse.success((data ?? [])).to_compatible();
+}
+async function insert_row(client, table, row) {
+    const { data, error: queryError } = await client
+        .from(table)
+        .insert(row)
+        .select("*")
+        .single();
+    return queryError
+        ? error(queryError.message)
+        : IWebResponse.success(data).to_compatible();
+}
+async function insert_with_creator(client, table, row) {
+    const user_id = await authenticated_user_id(client);
+    if (!user_id)
+        return error("authentication required");
+    const { data, error: queryError } = await client
+        .from(table)
+        .insert({ ...row, created_by: user_id })
+        .select("*")
+        .single();
+    return queryError
+        ? error(queryError.message)
+        : IWebResponse.success(data).to_compatible();
+}
+async function patch_row(client, table, id, updates, actor) {
+    const invalid = update_error(updates);
+    if (invalid)
+        return error(invalid);
+    const user_id = await authenticated_user_id(client);
+    if (!user_id)
+        return error("authentication required");
+    const payload = actor === "update"
+        ? with_update_actor(updates, user_id)
+        : with_lifecycle_actor(updates, user_id);
+    const { data, error: queryError } = await client
+        .from(table)
+        .update(payload)
+        .eq("id", id)
+        .select("*")
+        .single();
+    return queryError
+        ? error(queryError.message)
+        : IWebResponse.success(data).to_compatible();
+}
+export async function get_document_conditions_by_localization_query(client, localization_id, options) {
+    return list_by(client, "document_conditions", "localization_id", localization_id, options);
+}
+export async function create_document_condition_query(client, row) {
+    return insert_row(client, "document_conditions", row);
+}
+export async function update_document_condition_query(client, id, updates) {
+    return patch_row(client, "document_conditions", id, updates, "lifecycle");
+}
+export async function get_operating_context_types_by_localization_query(client, localization_id, options) {
+    return list_by(client, "operating_context_types", "localization_id", localization_id, options);
+}
+export async function create_operating_context_type_query(client, row) {
+    return insert_row(client, "operating_context_types", row);
+}
+export async function update_operating_context_type_query(client, id, updates) {
+    return patch_row(client, "operating_context_types", id, updates, "lifecycle");
+}
+export async function get_operating_context_roles_by_localization_query(client, localization_id, options) {
+    return list_by(client, "operating_context_roles", "localization_id", localization_id, options);
+}
+export async function create_operating_context_role_query(client, row) {
+    return insert_row(client, "operating_context_roles", row);
+}
+export async function update_operating_context_role_query(client, id, updates) {
+    return patch_row(client, "operating_context_roles", id, updates, "lifecycle");
+}
+export async function get_operating_context_equipment_categories_by_localization_query(client, localization_id, options) {
+    return list_by(client, "operating_context_equipment_categories", "localization_id", localization_id, options);
+}
+export async function create_operating_context_equipment_category_query(client, row) {
+    return insert_row(client, "operating_context_equipment_categories", row);
+}
+export async function update_operating_context_equipment_category_query(client, id, updates) {
+    return patch_row(client, "operating_context_equipment_categories", id, updates, "lifecycle");
+}
+export async function get_operating_context_equipment_items_by_category_query(client, equipment_category_id, options) {
+    return list_by(client, "operating_context_equipment_items", "equipment_category_id", equipment_category_id, options);
+}
+export async function create_operating_context_equipment_item_query(client, row) {
+    return insert_row(client, "operating_context_equipment_items", row);
+}
+export async function update_operating_context_equipment_item_query(client, id, updates) {
+    return patch_row(client, "operating_context_equipment_items", id, updates, "lifecycle");
+}
+export async function get_operating_contexts_by_herd_query(client, herd_id, options) {
+    return list_by(client, "operating_contexts", "herd_id", herd_id, options);
+}
+export async function get_operating_context_by_id_query(client, id) {
+    const { data, error: queryError } = await client
+        .from("operating_contexts")
+        .select("*")
+        .eq("id", id)
+        .maybeSingle();
+    return queryError
+        ? error(queryError.message)
+        : IWebResponse.success(data).to_compatible();
+}
+export async function create_operating_context_query(client, row) {
+    return insert_with_creator(client, "operating_contexts", row);
+}
+export async function update_operating_context_query(client, id, updates) {
+    return patch_row(client, "operating_contexts", id, updates, "update");
+}
+export async function get_operating_context_payloads_by_operating_context_query(client, operating_context_id, options) {
+    return list_by(client, "operating_context_payloads", "operating_context_id", operating_context_id, options);
+}
+export async function create_operating_context_payload_query(client, row) {
+    return insert_with_creator(client, "operating_context_payloads", row);
+}
+export async function update_operating_context_payload_query(client, id, updates) {
+    return patch_row(client, "operating_context_payloads", id, updates, "update");
+}
+export async function get_operating_context_role_assignments_by_operating_context_query(client, operating_context_id, options) {
+    return list_by(client, "operating_context_role_assignments", "operating_context_id", operating_context_id, options);
+}
+export async function create_operating_context_role_assignment_query(client, row) {
+    return insert_row(client, "operating_context_role_assignments", row);
+}
+export async function update_operating_context_role_assignment_query(client, id, updates) {
+    return patch_row(client, "operating_context_role_assignments", id, updates, "lifecycle");
+}
+export async function get_operating_context_devices_by_operating_context_query(client, operating_context_id, options) {
+    return list_by(client, "operating_contexts_devices", "operating_context_id", operating_context_id, options);
+}
+export async function create_operating_context_device_query(client, row) {
+    return insert_row(client, "operating_contexts_devices", row);
+}
+export async function update_operating_context_device_query(client, id, updates) {
+    return patch_row(client, "operating_contexts_devices", id, updates, "lifecycle");
+}
+export async function get_operating_context_equipment_requirements_by_operating_context_query(client, operating_context_id, options) {
+    return list_by(client, "operating_context_equipment_requirements", "operating_context_id", operating_context_id, options);
+}
+export async function create_operating_context_equipment_requirement_query(client, row) {
+    return insert_row(client, "operating_context_equipment_requirements", row);
+}
+export async function update_operating_context_equipment_requirement_query(client, id, updates) {
+    return patch_row(client, "operating_context_equipment_requirements", id, updates, "lifecycle");
+}
+export async function get_operating_context_regions_by_operating_context_query(client, operating_context_id, options) {
+    return list_by(client, "operating_context_regions", "operating_context_id", operating_context_id, options);
+}
+export async function create_operating_context_region_query(client, row) {
+    return insert_with_creator(client, "operating_context_regions", row);
+}
+export async function update_operating_context_region_query(client, id, updates) {
+    return patch_row(client, "operating_context_regions", id, updates, "update");
+}
+export async function get_operating_context_risks_by_operating_context_query(client, operating_context_id, options) {
+    return list_by(client, "operating_context_risks", "operating_context_id", operating_context_id, options);
+}
+export async function create_operating_context_risk_query(client, row) {
+    return insert_with_creator(client, "operating_context_risks", row);
+}
+export async function update_operating_context_risk_query(client, id, updates) {
+    return patch_row(client, "operating_context_risks", id, updates, "update");
+}
+export async function get_operating_context_weather_snapshots_query(client, operating_context_id, options) {
+    if (options?.limit != null &&
+        (options.limit < 1 || options.limit > 500)) {
+        return error("limit must be between 1 and 500");
+    }
+    const { data, error: queryError } = await client.rpc("get_operating_context_weather_snapshots", {
+        operating_context_id_caller: operating_context_id,
+        limit_caller: options?.limit,
+        cursor_collected_at: options?.cursor?.collected_at,
+        cursor_id: options?.cursor?.id,
+    });
+    return queryError
+        ? error(queryError.message)
+        : IWebResponse.success(data ?? []).to_compatible();
+}

package/dist/helpers/operators.js

@@ -1,64 +1,11 @@
-"use server";
 import { newServerClient } from "../supabase/server";
-import { EnumWebResponse, IWebResponse, } from "../types/requests";
-// Get operators by session id (server id)
+import { get_operators_by_session_id_filtered_query, get_operators_by_session_id_query, get_operators_by_user_id_query, } from "./operators.queries";
 export async function server_get_operators_by_session_id(sessionId) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("operators")
-        .select("*")
-        .eq("session_id", sessionId)
-        .order("created_at", { ascending: false });
-    if (error) {
-        console.warn("Error fetching operators by session id:", error.message);
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: [],
-        };
-    }
-    return IWebResponse.success(data || []).to_compatible();
+    return get_operators_by_session_id_query(await newServerClient(), sessionId);
 }
-// Get all operators for a specific user
 export async function server_get_operators_by_user_id(userId) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("operators")
-        .select("*")
-        .eq("user_id", userId)
-        .order("created_at", { ascending: false });
-    if (error) {
-        console.warn("Error fetching operators by user id:", error.message);
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: [],
-        };
-    }
-    return IWebResponse.success(data || []).to_compatible();
+    return get_operators_by_user_id_query(await newServerClient(), userId);
 }
-// Get operators by session id with additional filters
 export async function server_get_operators_by_session_id_filtered(sessionId, action, timestampAfter) {
-    const supabase = await newServerClient();
-    let query = supabase
-        .from("operators")
-        .select("*")
-        .eq("session_id", sessionId);
-    // Apply optional filters
-    if (action) {
-        query = query.eq("action", action);
-    }
-    if (timestampAfter) {
-        query = query.gte("timestamp", timestampAfter);
-    }
-    const { data, error } = await query.order("timestamp", { ascending: false });
-    if (error) {
-        console.warn("Error fetching filtered operators by session id:", error.message);
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: [],
-        };
-    }
-    return IWebResponse.success(data || []).to_compatible();
+    return get_operators_by_session_id_filtered_query(await newServerClient(), sessionId, action, timestampAfter);
 }

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

@@ -0,0 +1,7 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { IOperator } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+import { Database } from "../types/supabase";
+export declare function get_operators_by_session_id_query(client: SupabaseClient<Database>, sessionId: number): Promise<IWebResponseCompatible<IOperator[]>>;
+export declare function get_operators_by_user_id_query(client: SupabaseClient<Database>, userId: string): Promise<IWebResponseCompatible<IOperator[]>>;
+export declare function get_operators_by_session_id_filtered_query(client: SupabaseClient<Database>, sessionId: number, action?: string, timestampAfter?: string): Promise<IWebResponseCompatible<IOperator[]>>;

package/dist/helpers/operators.queries.js

@@ -0,0 +1,55 @@
+import { EnumWebResponse, IWebResponse, } from "../types/requests";
+export async function get_operators_by_session_id_query(client, sessionId) {
+    const { data, error } = await client
+        .from("operators")
+        .select("*")
+        .eq("session_id", sessionId)
+        .order("created_at", { ascending: false });
+    if (error) {
+        console.warn("Error fetching operators by session id:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: [],
+        };
+    }
+    return IWebResponse.success(data || []).to_compatible();
+}
+export async function get_operators_by_user_id_query(client, userId) {
+    const { data, error } = await client
+        .from("operators")
+        .select("*")
+        .eq("user_id", userId)
+        .order("created_at", { ascending: false });
+    if (error) {
+        console.warn("Error fetching operators by user id:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: [],
+        };
+    }
+    return IWebResponse.success(data || []).to_compatible();
+}
+export async function get_operators_by_session_id_filtered_query(client, sessionId, action, timestampAfter) {
+    let query = client
+        .from("operators")
+        .select("*")
+        .eq("session_id", sessionId);
+    if (action) {
+        query = query.eq("action", action);
+    }
+    if (timestampAfter) {
+        query = query.gte("timestamp", timestampAfter);
+    }
+    const { data, error } = await query.order("timestamp", { ascending: false });
+    if (error) {
+        console.warn("Error fetching filtered operators by session id:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: [],
+        };
+    }
+    return IWebResponse.success(data || []).to_compatible();
+}

package/dist/helpers/parts.d.ts

@@ -3,108 +3,21 @@ import { EntityLifecycle, IPart, IPartWithProduct, PartInsert } from "../types/d
 import { IWebResponseCompatible } from "../types/requests";
 import { SupabaseClient } from "@supabase/supabase-js";
 import { LifecycleUpdateOptions } from "./lifecycle";
-/**
- * Retrieves all active parts for a specific device
- * @param client - Supabase client instance
- * @param device_id - ID of the device to get parts for
- */
 export declare function get_parts_by_device_id(client: SupabaseClient<Database>, device_id: number): Promise<IWebResponseCompatible<IPart[]>>;
-/**
- * Retrieves a single active part by its ID
- * @param client - Supabase client instance
- * @param part_id - ID of the part to retrieve
- */
 export declare function get_part_by_id(client: SupabaseClient<Database>, part_id: number): Promise<IWebResponseCompatible<IPart | null>>;
-/**
- * Retrieves all active parts with a specific serial number
- * @param client - Supabase client instance
- * @param serial_number - Serial number to search for
- */
 export declare function get_parts_by_serial_number(client: SupabaseClient<Database>, serial_number: string): Promise<IWebResponseCompatible<IPart[]>>;
-/**
- * Retrieves all active parts with a specific product number
- * @param client - Supabase client instance
- * @param product_number - Product number to search for
- */
 export declare function get_parts_by_product_number(client: SupabaseClient<Database>, product_number: string): Promise<IWebResponseCompatible<IPart[]>>;
-/**
- * Retrieves all parts with a specific lifecycle state
- * @param client - Supabase client instance
- * @param lifecycle - Lifecycle state to filter by
- */
 export declare function get_parts_by_lifecycle(client: SupabaseClient<Database>, lifecycle: EntityLifecycle): Promise<IWebResponseCompatible<IPart[]>>;
 /** @deprecated Use get_parts_by_lifecycle */
 export declare const get_parts_by_status: typeof get_parts_by_lifecycle;
-/**
- * Creates a new part with validation
- * @param client - Supabase client instance
- * @param newPart - Part data to create
- */
 export declare function create_part(client: SupabaseClient<Database>, newPart: PartInsert): Promise<IWebResponseCompatible<IPart | null>>;
-/**
- * Updates an existing part
- * @param client - Supabase client instance
- * @param part_id - ID of the part to update
- * @param updatedPart - Partial part data to update
- */
 export declare function update_part(client: SupabaseClient<Database>, part_id: number, updatedPart: Partial<PartInsert>): Promise<IWebResponseCompatible<IPart | null>>;
-/**
- * Marks an active part as deleted (lifecycle)
- * @param client - Supabase client instance
- * @param part_id - ID of the part to delete
- * @param options - Optional lifecycle metadata
- */
 export declare function delete_part(client: SupabaseClient<Database>, part_id: number, options?: LifecycleUpdateOptions): Promise<IWebResponseCompatible<IPart | null>>;
-/**
- * Updates the lifecycle of a specific part
- * @param client - Supabase client instance
- * @param part_id - ID of the part to update
- * @param lifecycle - New lifecycle state
- * @param options - Optional lifecycle metadata
- */
 export declare function update_part_status(client: SupabaseClient<Database>, part_id: number, lifecycle: EntityLifecycle, options?: LifecycleUpdateOptions): Promise<IWebResponseCompatible<IPart | null>>;
-/**
- * Retrieves all active parts associated with a certificate
- * @param client - Supabase client instance
- * @param certificate_id - ID of the certificate to search for
- */
 export declare function get_parts_by_certificate_id(client: SupabaseClient<Database>, certificate_id: number): Promise<IWebResponseCompatible<IPart[]>>;
-/**
- * Retrieves all active parts for a herd
- * @param client - Supabase client instance
- * @param herd_id - ID of the herd to get parts for
- */
 export declare function get_parts_by_herd_id(client: SupabaseClient<Database>, herd_id: number): Promise<IWebResponseCompatible<IPart[]>>;
-/**
- * Retrieves active parts for all devices across many herds in one query,
- * grouped by device_id.
- * @param client - Supabase client instance
- * @param herd_ids - IDs of the herds to get parts for
- */
 export declare function get_parts_by_herd_ids(client: SupabaseClient<Database>, herd_ids: number[]): Promise<IWebResponseCompatible<Record<number, IPartWithProduct[]>>>;
-/**
- * Restores a deleted part to active lifecycle
- * @param client - Supabase client instance
- * @param part_id - ID of the part to restore
- * @param options - Optional lifecycle metadata
- */
 export declare function restore_part(client: SupabaseClient<Database>, part_id: number, options?: LifecycleUpdateOptions): Promise<IWebResponseCompatible<IPart | null>>;
-/**
- * Permanently deletes a part that is already in deleted lifecycle
- * @param client - Supabase client instance
- * @param part_id - ID of the part to permanently delete
- */
 export declare function hard_delete_part(client: SupabaseClient<Database>, part_id: number): Promise<IWebResponseCompatible<IPart | null>>;
-/**
- * Retrieves all deleted parts for a specific device
- * @param client - Supabase client instance
- * @param device_id - ID of the device to get deleted parts for
- */
 export declare function get_deleted_parts_by_device_id(client: SupabaseClient<Database>, device_id: number): Promise<IWebResponseCompatible<IPart[]>>;
-/**
- * Retrieves a part by its composite unique constraint (product + serial)
- * @param client - Supabase client instance
- * @param product_number - Product number to search for
- * @param serial_number - Serial number to search for
- */
 export declare function get_parts_by_product_and_serial(client: SupabaseClient<Database>, product_number: string, serial_number: string): Promise<IWebResponseCompatible<IPart | null>>;

package/dist/helpers/parts.js

@@ -1,10 +1,5 @@
 import { IWebResponse } from "../types/requests";
 import { update_part_lifecycle } from "./lifecycle";
-/**
- * Retrieves all active parts for a specific device
- * @param client - Supabase client instance
- * @param device_id - ID of the device to get parts for
- */
 export async function get_parts_by_device_id(client, device_id) {
     const { data, error } = await client
         .from("parts")
@@ -20,11 +15,6 @@ export async function get_parts_by_device_id(client, device_id) {
     }
     return IWebResponse.success(data).to_compatible();
 }
-/**
- * Retrieves a single active part by its ID
- * @param client - Supabase client instance
- * @param part_id - ID of the part to retrieve
- */
 export async function get_part_by_id(client, part_id) {
     const { data, error } = await client
         .from("parts")
@@ -40,11 +30,6 @@ export async function get_part_by_id(client, part_id) {
     }
     return IWebResponse.success(data).to_compatible();
 }
-/**
- * Retrieves all active parts with a specific serial number
- * @param client - Supabase client instance
- * @param serial_number - Serial number to search for
- */
 export async function get_parts_by_serial_number(client, serial_number) {
     const { data, error } = await client
         .from("parts")
@@ -60,11 +45,6 @@ export async function get_parts_by_serial_number(client, serial_number) {
     }
     return IWebResponse.success(data).to_compatible();
 }
-/**
- * Retrieves all active parts with a specific product number
- * @param client - Supabase client instance
- * @param product_number - Product number to search for
- */
 export async function get_parts_by_product_number(client, product_number) {
     const { data, error } = await client
         .from("parts")
@@ -80,11 +60,6 @@ export async function get_parts_by_product_number(client, product_number) {
     }
     return IWebResponse.success(data).to_compatible();
 }
-/**
- * Retrieves all parts with a specific lifecycle state
- * @param client - Supabase client instance
- * @param lifecycle - Lifecycle state to filter by
- */
 export async function get_parts_by_lifecycle(client, lifecycle) {
     const { data, error } = await client
         .from("parts")
@@ -101,13 +76,8 @@ export async function get_parts_by_lifecycle(client, lifecycle) {
 }
 /** @deprecated Use get_parts_by_lifecycle */
 export const get_parts_by_status = get_parts_by_lifecycle;
-/**
- * Creates a new part with validation
- * @param client - Supabase client instance
- * @param newPart - Part data to create
- */
 export async function create_part(client, newPart) {
-    // part is scoped to exactly one of a device or a herd.
+    // A part belongs to one device or one herd.
     const scope_count = [newPart.device_id, newPart.herd_id].filter((scope) => scope != null).length;
     if (scope_count !== 1) {
         return IWebResponse.error("exactly one of device_id or herd_id is required").to_compatible();
@@ -131,14 +101,7 @@ export async function create_part(client, newPart) {
     }
     return IWebResponse.success(data).to_compatible();
 }
-/**
- * Updates an existing part
- * @param client - Supabase client instance
- * @param part_id - ID of the part to update
- * @param updatedPart - Partial part data to update
- */
 export async function update_part(client, part_id, updatedPart) {
-    // Remove fields that shouldn't be updated
     const updateData = { ...updatedPart };
     delete updateData.id;
     delete updateData.created_at;
@@ -156,12 +119,6 @@ export async function update_part(client, part_id, updatedPart) {
     }
     return IWebResponse.success(data).to_compatible();
 }
-/**
- * Marks an active part as deleted (lifecycle)
- * @param client - Supabase client instance
- * @param part_id - ID of the part to delete
- * @param options - Optional lifecycle metadata
- */
 export async function delete_part(client, part_id, options) {
     const { data, error } = await client
         .from("parts")
@@ -186,21 +143,9 @@ export async function delete_part(client, part_id, options) {
     }
     return IWebResponse.success(data).to_compatible();
 }
-/**
- * Updates the lifecycle of a specific part
- * @param client - Supabase client instance
- * @param part_id - ID of the part to update
- * @param lifecycle - New lifecycle state
- * @param options - Optional lifecycle metadata
- */
 export async function update_part_status(client, part_id, lifecycle, options) {
     return update_part_lifecycle(client, part_id, lifecycle, options);
 }
-/**
- * Retrieves all active parts associated with a certificate
- * @param client - Supabase client instance
- * @param certificate_id - ID of the certificate to search for
- */
 export async function get_parts_by_certificate_id(client, certificate_id) {
     const { data, error } = await client
         .from("parts")
@@ -216,11 +161,6 @@ export async function get_parts_by_certificate_id(client, certificate_id) {
     }
     return IWebResponse.success(data).to_compatible();
 }
-/**
- * Retrieves all active parts for a herd
- * @param client - Supabase client instance
- * @param herd_id - ID of the herd to get parts for
- */
 export async function get_parts_by_herd_id(client, herd_id) {
     const { data, error } = await client.rpc("get_parts_for_herd", {
         herd_id_caller: herd_id,
@@ -230,12 +170,6 @@ export async function get_parts_by_herd_id(client, herd_id) {
     }
     return IWebResponse.success(data ?? []).to_compatible();
 }
-/**
- * Retrieves active parts for all devices across many herds in one query,
- * grouped by device_id.
- * @param client - Supabase client instance
- * @param herd_ids - IDs of the herds to get parts for
- */
 export async function get_parts_by_herd_ids(client, herd_ids) {
     var _a;
     if (herd_ids.length === 0) {
@@ -246,7 +180,9 @@ export async function get_parts_by_herd_ids(client, herd_ids) {
         .select(`
       *,
       devices!parts_device_id_fkey(herd_id),
-      product_numbers!parts_product_number_fkey(products(*))
+      product_numbers!parts_product_number_fkey(
+        products!product_numbers_product_id_fkey(*)
+      )
     `)
         .in("devices.herd_id", herd_ids)
         .eq("lifecycle", "active")
@@ -268,12 +204,6 @@ export async function get_parts_by_herd_ids(client, herd_ids) {
     }
     return IWebResponse.success(grouped).to_compatible();
 }
-/**
- * Restores a deleted part to active lifecycle
- * @param client - Supabase client instance
- * @param part_id - ID of the part to restore
- * @param options - Optional lifecycle metadata
- */
 export async function restore_part(client, part_id, options) {
     const { data, error } = await client
         .from("parts")
@@ -298,11 +228,6 @@ export async function restore_part(client, part_id, options) {
     }
     return IWebResponse.success(data).to_compatible();
 }
-/**
- * Permanently deletes a part that is already in deleted lifecycle
- * @param client - Supabase client instance
- * @param part_id - ID of the part to permanently delete
- */
 export async function hard_delete_part(client, part_id) {
     const { data, error } = await client
         .from("parts")
@@ -319,11 +244,6 @@ export async function hard_delete_part(client, part_id) {
     }
     return IWebResponse.success(data).to_compatible();
 }
-/**
- * Retrieves all deleted parts for a specific device
- * @param client - Supabase client instance
- * @param device_id - ID of the device to get deleted parts for
- */
 export async function get_deleted_parts_by_device_id(client, device_id) {
     const { data, error } = await client
         .from("parts")
@@ -339,12 +259,6 @@ export async function get_deleted_parts_by_device_id(client, device_id) {
     }
     return IWebResponse.success(data).to_compatible();
 }
-/**
- * Retrieves a part by its composite unique constraint (product + serial)
- * @param client - Supabase client instance
- * @param product_number - Product number to search for
- * @param serial_number - Serial number to search for
- */
 export async function get_parts_by_product_and_serial(client, product_number, serial_number) {
     const { data, error } = await client
         .from("parts")