@adventurelabs/scout-core 1.5.5 → 2.0.1

package/dist/helpers/operating_contexts.js

@@ -1,231 +1,116 @@
-"use server";
 import { newServerClient } from "../supabase/server";
-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(table, column, value, options) {
-    const limit = page_limit(options);
-    if (limit == null)
-        return error("limit must be between 1 and 500");
-    const supabase = await newServerClient();
-    let query = supabase
-        .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(table, row) {
-    const supabase = await newServerClient();
-    const { data, error: queryError } = await supabase
-        .from(table)
-        .insert(row)
-        .select("*")
-        .single();
-    return queryError
-        ? error(queryError.message)
-        : IWebResponse.success(data).to_compatible();
-}
-async function insert_with_creator(table, row) {
-    const supabase = await newServerClient();
-    const user_id = await authenticated_user_id(supabase);
-    if (!user_id)
-        return error("authentication required");
-    const { data, error: queryError } = await supabase
-        .from(table)
-        .insert({ ...row, created_by: user_id })
-        .select("*")
-        .single();
-    return queryError
-        ? error(queryError.message)
-        : IWebResponse.success(data).to_compatible();
-}
-async function patch_row(table, id, updates, actor) {
-    const invalid = update_error(updates);
-    if (invalid)
-        return error(invalid);
-    const supabase = await newServerClient();
-    const user_id = await authenticated_user_id(supabase);
-    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 supabase
-        .from(table)
-        .update(payload)
-        .eq("id", id)
-        .select("*")
-        .single();
-    return queryError
-        ? error(queryError.message)
-        : IWebResponse.success(data).to_compatible();
-}
+import * as queries from "./operating_contexts.queries";
 export async function server_get_document_conditions_by_localization(localization_id, options) {
-    return list_by("document_conditions", "localization_id", localization_id, options);
+    return queries.get_document_conditions_by_localization_query(await newServerClient(), localization_id, options);
 }
 export async function server_create_document_condition(row) {
-    return insert_row("document_conditions", row);
+    return queries.create_document_condition_query(await newServerClient(), row);
 }
 export async function server_update_document_condition(id, updates) {
-    return patch_row("document_conditions", id, updates, "lifecycle");
+    return queries.update_document_condition_query(await newServerClient(), id, updates);
 }
 export async function server_get_operating_context_types_by_localization(localization_id, options) {
-    return list_by("operating_context_types", "localization_id", localization_id, options);
+    return queries.get_operating_context_types_by_localization_query(await newServerClient(), localization_id, options);
 }
 export async function server_create_operating_context_type(row) {
-    return insert_row("operating_context_types", row);
+    return queries.create_operating_context_type_query(await newServerClient(), row);
 }
 export async function server_update_operating_context_type(id, updates) {
-    return patch_row("operating_context_types", id, updates, "lifecycle");
+    return queries.update_operating_context_type_query(await newServerClient(), id, updates);
 }
 export async function server_get_operating_context_roles_by_localization(localization_id, options) {
-    return list_by("operating_context_roles", "localization_id", localization_id, options);
+    return queries.get_operating_context_roles_by_localization_query(await newServerClient(), localization_id, options);
 }
 export async function server_create_operating_context_role(row) {
-    return insert_row("operating_context_roles", row);
+    return queries.create_operating_context_role_query(await newServerClient(), row);
 }
 export async function server_update_operating_context_role(id, updates) {
-    return patch_row("operating_context_roles", id, updates, "lifecycle");
+    return queries.update_operating_context_role_query(await newServerClient(), id, updates);
 }
 export async function server_get_operating_context_equipment_categories_by_localization(localization_id, options) {
-    return list_by("operating_context_equipment_categories", "localization_id", localization_id, options);
+    return queries.get_operating_context_equipment_categories_by_localization_query(await newServerClient(), localization_id, options);
 }
 export async function server_create_operating_context_equipment_category(row) {
-    return insert_row("operating_context_equipment_categories", row);
+    return queries.create_operating_context_equipment_category_query(await newServerClient(), row);
 }
 export async function server_update_operating_context_equipment_category(id, updates) {
-    return patch_row("operating_context_equipment_categories", id, updates, "lifecycle");
+    return queries.update_operating_context_equipment_category_query(await newServerClient(), id, updates);
 }
 export async function server_get_operating_context_equipment_items_by_category(equipment_category_id, options) {
-    return list_by("operating_context_equipment_items", "equipment_category_id", equipment_category_id, options);
+    return queries.get_operating_context_equipment_items_by_category_query(await newServerClient(), equipment_category_id, options);
 }
 export async function server_create_operating_context_equipment_item(row) {
-    return insert_row("operating_context_equipment_items", row);
+    return queries.create_operating_context_equipment_item_query(await newServerClient(), row);
 }
 export async function server_update_operating_context_equipment_item(id, updates) {
-    return patch_row("operating_context_equipment_items", id, updates, "lifecycle");
+    return queries.update_operating_context_equipment_item_query(await newServerClient(), id, updates);
 }
 export async function server_get_operating_contexts_by_herd(herd_id, options) {
-    return list_by("operating_contexts", "herd_id", herd_id, options);
+    return queries.get_operating_contexts_by_herd_query(await newServerClient(), herd_id, options);
 }
 export async function server_get_operating_context_by_id(id) {
-    const supabase = await newServerClient();
-    const { data, error: queryError } = await supabase
-        .from("operating_contexts")
-        .select("*")
-        .eq("id", id)
-        .maybeSingle();
-    return queryError
-        ? error(queryError.message)
-        : IWebResponse.success(data).to_compatible();
+    return queries.get_operating_context_by_id_query(await newServerClient(), id);
 }
 export async function server_create_operating_context(row) {
-    return insert_with_creator("operating_contexts", row);
+    return queries.create_operating_context_query(await newServerClient(), row);
 }
 export async function server_update_operating_context(id, updates) {
-    return patch_row("operating_contexts", id, updates, "update");
+    return queries.update_operating_context_query(await newServerClient(), id, updates);
 }
 export async function server_get_operating_context_payloads_by_operating_context(operating_context_id, options) {
-    return list_by("operating_context_payloads", "operating_context_id", operating_context_id, options);
+    return queries.get_operating_context_payloads_by_operating_context_query(await newServerClient(), operating_context_id, options);
 }
 export async function server_create_operating_context_payload(row) {
-    return insert_with_creator("operating_context_payloads", row);
+    return queries.create_operating_context_payload_query(await newServerClient(), row);
 }
 export async function server_update_operating_context_payload(id, updates) {
-    return patch_row("operating_context_payloads", id, updates, "update");
+    return queries.update_operating_context_payload_query(await newServerClient(), id, updates);
 }
 export async function server_get_operating_context_role_assignments_by_operating_context(operating_context_id, options) {
-    return list_by("operating_context_role_assignments", "operating_context_id", operating_context_id, options);
+    return queries.get_operating_context_role_assignments_by_operating_context_query(await newServerClient(), operating_context_id, options);
 }
 export async function server_create_operating_context_role_assignment(row) {
-    return insert_row("operating_context_role_assignments", row);
+    return queries.create_operating_context_role_assignment_query(await newServerClient(), row);
 }
 export async function server_update_operating_context_role_assignment(id, updates) {
-    return patch_row("operating_context_role_assignments", id, updates, "lifecycle");
+    return queries.update_operating_context_role_assignment_query(await newServerClient(), id, updates);
 }
 export async function server_get_operating_context_devices_by_operating_context(operating_context_id, options) {
-    return list_by("operating_contexts_devices", "operating_context_id", operating_context_id, options);
+    return queries.get_operating_context_devices_by_operating_context_query(await newServerClient(), operating_context_id, options);
 }
 export async function server_create_operating_context_device(row) {
-    return insert_row("operating_contexts_devices", row);
+    return queries.create_operating_context_device_query(await newServerClient(), row);
 }
 export async function server_update_operating_context_device(id, updates) {
-    return patch_row("operating_contexts_devices", id, updates, "lifecycle");
+    return queries.update_operating_context_device_query(await newServerClient(), id, updates);
 }
 export async function server_get_operating_context_equipment_requirements_by_operating_context(operating_context_id, options) {
-    return list_by("operating_context_equipment_requirements", "operating_context_id", operating_context_id, options);
+    return queries.get_operating_context_equipment_requirements_by_operating_context_query(await newServerClient(), operating_context_id, options);
 }
 export async function server_create_operating_context_equipment_requirement(row) {
-    return insert_row("operating_context_equipment_requirements", row);
+    return queries.create_operating_context_equipment_requirement_query(await newServerClient(), row);
 }
 export async function server_update_operating_context_equipment_requirement(id, updates) {
-    return patch_row("operating_context_equipment_requirements", id, updates, "lifecycle");
+    return queries.update_operating_context_equipment_requirement_query(await newServerClient(), id, updates);
 }
 export async function server_get_operating_context_regions_by_operating_context(operating_context_id, options) {
-    return list_by("operating_context_regions", "operating_context_id", operating_context_id, options);
+    return queries.get_operating_context_regions_by_operating_context_query(await newServerClient(), operating_context_id, options);
 }
 export async function server_create_operating_context_region(row) {
-    return insert_with_creator("operating_context_regions", row);
+    return queries.create_operating_context_region_query(await newServerClient(), row);
 }
 export async function server_update_operating_context_region(id, updates) {
-    return patch_row("operating_context_regions", id, updates, "update");
+    return queries.update_operating_context_region_query(await newServerClient(), id, updates);
 }
 export async function server_get_operating_context_risks_by_operating_context(operating_context_id, options) {
-    return list_by("operating_context_risks", "operating_context_id", operating_context_id, options);
+    return queries.get_operating_context_risks_by_operating_context_query(await newServerClient(), operating_context_id, options);
 }
 export async function server_create_operating_context_risk(row) {
-    return insert_with_creator("operating_context_risks", row);
+    return queries.create_operating_context_risk_query(await newServerClient(), row);
 }
 export async function server_update_operating_context_risk(id, updates) {
-    return patch_row("operating_context_risks", id, updates, "update");
+    return queries.update_operating_context_risk_query(await newServerClient(), id, updates);
 }
 export async function server_get_operating_context_weather_snapshots(operating_context_id, options) {
-    if (options?.limit != null &&
-        (options.limit < 1 || options.limit > 500)) {
-        return error("limit must be between 1 and 500");
-    }
-    const supabase = await newServerClient();
-    const { data, error: queryError } = await supabase.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();
+    return queries.get_operating_context_weather_snapshots_query(await newServerClient(), operating_context_id, options);
 }

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

@@ -0,0 +1,48 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { DocumentConditionCreateInput, DocumentConditionUpdateInput, IDocumentCondition, IOperatingContext, IOperatingContextDevice, IOperatingContextEquipmentCategory, IOperatingContextEquipmentItem, IOperatingContextEquipmentRequirement, IOperatingContextPayload, IOperatingContextRegion, IOperatingContextRisk, IOperatingContextRole, IOperatingContextRoleAssignment, IOperatingContextType, IOperatingContextWeatherSnapshot, OperatingContextCreateInput, OperatingContextDeviceCreateInput, OperatingContextDeviceUpdateInput, OperatingContextEquipmentCategoryCreateInput, OperatingContextEquipmentCategoryUpdateInput, OperatingContextEquipmentItemCreateInput, OperatingContextEquipmentItemUpdateInput, OperatingContextEquipmentRequirementCreateInput, OperatingContextEquipmentRequirementUpdateInput, OperatingContextListOptions, OperatingContextPayloadCreateInput, OperatingContextPayloadUpdateInput, OperatingContextRegionCreateInput, OperatingContextRegionUpdateInput, OperatingContextRiskCreateInput, OperatingContextRiskUpdateInput, OperatingContextRoleAssignmentCreateInput, OperatingContextRoleAssignmentUpdateInput, OperatingContextRoleCreateInput, OperatingContextRoleUpdateInput, OperatingContextTypeCreateInput, OperatingContextTypeUpdateInput, OperatingContextUpdateInput } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+import { Database } from "../types/supabase";
+export declare function get_document_conditions_by_localization_query(client: SupabaseClient<Database>, localization_id: number, options?: OperatingContextListOptions): Promise<IWebResponseCompatible<IDocumentCondition[]>>;
+export declare function create_document_condition_query(client: SupabaseClient<Database>, row: DocumentConditionCreateInput): Promise<IWebResponseCompatible<IDocumentCondition | null>>;
+export declare function update_document_condition_query(client: SupabaseClient<Database>, id: number, updates: DocumentConditionUpdateInput): Promise<IWebResponseCompatible<IDocumentCondition | null>>;
+export declare function get_operating_context_types_by_localization_query(client: SupabaseClient<Database>, localization_id: number, options?: OperatingContextListOptions): Promise<IWebResponseCompatible<IOperatingContextType[]>>;
+export declare function create_operating_context_type_query(client: SupabaseClient<Database>, row: OperatingContextTypeCreateInput): Promise<IWebResponseCompatible<IOperatingContextType | null>>;
+export declare function update_operating_context_type_query(client: SupabaseClient<Database>, id: number, updates: OperatingContextTypeUpdateInput): Promise<IWebResponseCompatible<IOperatingContextType | null>>;
+export declare function get_operating_context_roles_by_localization_query(client: SupabaseClient<Database>, localization_id: number, options?: OperatingContextListOptions): Promise<IWebResponseCompatible<IOperatingContextRole[]>>;
+export declare function create_operating_context_role_query(client: SupabaseClient<Database>, row: OperatingContextRoleCreateInput): Promise<IWebResponseCompatible<IOperatingContextRole | null>>;
+export declare function update_operating_context_role_query(client: SupabaseClient<Database>, id: number, updates: OperatingContextRoleUpdateInput): Promise<IWebResponseCompatible<IOperatingContextRole | null>>;
+export declare function get_operating_context_equipment_categories_by_localization_query(client: SupabaseClient<Database>, localization_id: number, options?: OperatingContextListOptions): Promise<IWebResponseCompatible<IOperatingContextEquipmentCategory[]>>;
+export declare function create_operating_context_equipment_category_query(client: SupabaseClient<Database>, row: OperatingContextEquipmentCategoryCreateInput): Promise<IWebResponseCompatible<IOperatingContextEquipmentCategory | null>>;
+export declare function update_operating_context_equipment_category_query(client: SupabaseClient<Database>, id: number, updates: OperatingContextEquipmentCategoryUpdateInput): Promise<IWebResponseCompatible<IOperatingContextEquipmentCategory | null>>;
+export declare function get_operating_context_equipment_items_by_category_query(client: SupabaseClient<Database>, equipment_category_id: number, options?: OperatingContextListOptions): Promise<IWebResponseCompatible<IOperatingContextEquipmentItem[]>>;
+export declare function create_operating_context_equipment_item_query(client: SupabaseClient<Database>, row: OperatingContextEquipmentItemCreateInput): Promise<IWebResponseCompatible<IOperatingContextEquipmentItem | null>>;
+export declare function update_operating_context_equipment_item_query(client: SupabaseClient<Database>, id: number, updates: OperatingContextEquipmentItemUpdateInput): Promise<IWebResponseCompatible<IOperatingContextEquipmentItem | null>>;
+export declare function get_operating_contexts_by_herd_query(client: SupabaseClient<Database>, herd_id: number, options?: OperatingContextListOptions): Promise<IWebResponseCompatible<IOperatingContext[]>>;
+export declare function get_operating_context_by_id_query(client: SupabaseClient<Database>, id: number): Promise<IWebResponseCompatible<IOperatingContext | null>>;
+export declare function create_operating_context_query(client: SupabaseClient<Database>, row: OperatingContextCreateInput): Promise<IWebResponseCompatible<IOperatingContext | null>>;
+export declare function update_operating_context_query(client: SupabaseClient<Database>, id: number, updates: OperatingContextUpdateInput): Promise<IWebResponseCompatible<IOperatingContext | null>>;
+export declare function get_operating_context_payloads_by_operating_context_query(client: SupabaseClient<Database>, operating_context_id: number, options?: OperatingContextListOptions): Promise<IWebResponseCompatible<IOperatingContextPayload[]>>;
+export declare function create_operating_context_payload_query(client: SupabaseClient<Database>, row: OperatingContextPayloadCreateInput): Promise<IWebResponseCompatible<IOperatingContextPayload | null>>;
+export declare function update_operating_context_payload_query(client: SupabaseClient<Database>, id: number, updates: OperatingContextPayloadUpdateInput): Promise<IWebResponseCompatible<IOperatingContextPayload | null>>;
+export declare function get_operating_context_role_assignments_by_operating_context_query(client: SupabaseClient<Database>, operating_context_id: number, options?: OperatingContextListOptions): Promise<IWebResponseCompatible<IOperatingContextRoleAssignment[]>>;
+export declare function create_operating_context_role_assignment_query(client: SupabaseClient<Database>, row: OperatingContextRoleAssignmentCreateInput): Promise<IWebResponseCompatible<IOperatingContextRoleAssignment | null>>;
+export declare function update_operating_context_role_assignment_query(client: SupabaseClient<Database>, id: number, updates: OperatingContextRoleAssignmentUpdateInput): Promise<IWebResponseCompatible<IOperatingContextRoleAssignment | null>>;
+export declare function get_operating_context_devices_by_operating_context_query(client: SupabaseClient<Database>, operating_context_id: number, options?: OperatingContextListOptions): Promise<IWebResponseCompatible<IOperatingContextDevice[]>>;
+export declare function create_operating_context_device_query(client: SupabaseClient<Database>, row: OperatingContextDeviceCreateInput): Promise<IWebResponseCompatible<IOperatingContextDevice | null>>;
+export declare function update_operating_context_device_query(client: SupabaseClient<Database>, id: number, updates: OperatingContextDeviceUpdateInput): Promise<IWebResponseCompatible<IOperatingContextDevice | null>>;
+export declare function get_operating_context_equipment_requirements_by_operating_context_query(client: SupabaseClient<Database>, operating_context_id: number, options?: OperatingContextListOptions): Promise<IWebResponseCompatible<IOperatingContextEquipmentRequirement[]>>;
+export declare function create_operating_context_equipment_requirement_query(client: SupabaseClient<Database>, row: OperatingContextEquipmentRequirementCreateInput): Promise<IWebResponseCompatible<IOperatingContextEquipmentRequirement | null>>;
+export declare function update_operating_context_equipment_requirement_query(client: SupabaseClient<Database>, id: number, updates: OperatingContextEquipmentRequirementUpdateInput): Promise<IWebResponseCompatible<IOperatingContextEquipmentRequirement | null>>;
+export declare function get_operating_context_regions_by_operating_context_query(client: SupabaseClient<Database>, operating_context_id: number, options?: OperatingContextListOptions): Promise<IWebResponseCompatible<IOperatingContextRegion[]>>;
+export declare function create_operating_context_region_query(client: SupabaseClient<Database>, row: OperatingContextRegionCreateInput): Promise<IWebResponseCompatible<IOperatingContextRegion | null>>;
+export declare function update_operating_context_region_query(client: SupabaseClient<Database>, id: number, updates: OperatingContextRegionUpdateInput): Promise<IWebResponseCompatible<IOperatingContextRegion | null>>;
+export declare function get_operating_context_risks_by_operating_context_query(client: SupabaseClient<Database>, operating_context_id: number, options?: OperatingContextListOptions): Promise<IWebResponseCompatible<IOperatingContextRisk[]>>;
+export declare function create_operating_context_risk_query(client: SupabaseClient<Database>, row: OperatingContextRiskCreateInput): Promise<IWebResponseCompatible<IOperatingContextRisk | null>>;
+export declare function update_operating_context_risk_query(client: SupabaseClient<Database>, id: number, updates: OperatingContextRiskUpdateInput): Promise<IWebResponseCompatible<IOperatingContextRisk | null>>;
+export declare function get_operating_context_weather_snapshots_query(client: SupabaseClient<Database>, operating_context_id: number, options?: {
+    limit?: number;
+    cursor?: {
+        collected_at: string;
+        id: number;
+    };
+}): Promise<IWebResponseCompatible<IOperatingContextWeatherSnapshot[]>>;

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