@adventurelabs/scout-core 1.4.96 → 1.5.1

package/dist/helpers/operating_contexts.js

@@ -0,0 +1,222 @@
+"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();
+}
+export async function server_get_document_conditions_by_localization(localization_id, options) {
+    return list_by("document_conditions", "localization_id", localization_id, options);
+}
+export async function server_create_document_condition(row) {
+    return insert_row("document_conditions", row);
+}
+export async function server_update_document_condition(id, updates) {
+    return patch_row("document_conditions", id, updates, "lifecycle");
+}
+export async function server_get_operating_context_types_by_localization(localization_id, options) {
+    return list_by("operating_context_types", "localization_id", localization_id, options);
+}
+export async function server_create_operating_context_type(row) {
+    return insert_row("operating_context_types", row);
+}
+export async function server_update_operating_context_type(id, updates) {
+    return patch_row("operating_context_types", id, updates, "lifecycle");
+}
+export async function server_get_operating_context_roles_by_localization(localization_id, options) {
+    return list_by("operating_context_roles", "localization_id", localization_id, options);
+}
+export async function server_create_operating_context_role(row) {
+    return insert_row("operating_context_roles", row);
+}
+export async function server_update_operating_context_role(id, updates) {
+    return patch_row("operating_context_roles", id, updates, "lifecycle");
+}
+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);
+}
+export async function server_create_operating_context_equipment_category(row) {
+    return insert_row("operating_context_equipment_categories", row);
+}
+export async function server_update_operating_context_equipment_category(id, updates) {
+    return patch_row("operating_context_equipment_categories", id, updates, "lifecycle");
+}
+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);
+}
+export async function server_create_operating_context_equipment_item(row) {
+    return insert_row("operating_context_equipment_items", row);
+}
+export async function server_update_operating_context_equipment_item(id, updates) {
+    return patch_row("operating_context_equipment_items", id, updates, "lifecycle");
+}
+export async function server_get_operating_contexts_by_herd(herd_id, options) {
+    return list_by("operating_contexts", "herd_id", 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();
+}
+export async function server_create_operating_context(row) {
+    return insert_with_creator("operating_contexts", row);
+}
+export async function server_update_operating_context(id, updates) {
+    return patch_row("operating_contexts", id, updates, "update");
+}
+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);
+}
+export async function server_create_operating_context_payload(row) {
+    return insert_with_creator("operating_context_payloads", row);
+}
+export async function server_update_operating_context_payload(id, updates) {
+    return patch_row("operating_context_payloads", id, updates, "update");
+}
+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);
+}
+export async function server_create_operating_context_role_assignment(row) {
+    return insert_row("operating_context_role_assignments", row);
+}
+export async function server_update_operating_context_role_assignment(id, updates) {
+    return patch_row("operating_context_role_assignments", id, updates, "lifecycle");
+}
+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);
+}
+export async function server_create_operating_context_equipment_requirement(row) {
+    return insert_row("operating_context_equipment_requirements", row);
+}
+export async function server_update_operating_context_equipment_requirement(id, updates) {
+    return patch_row("operating_context_equipment_requirements", id, updates, "lifecycle");
+}
+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);
+}
+export async function server_create_operating_context_region(row) {
+    return insert_with_creator("operating_context_regions", row);
+}
+export async function server_update_operating_context_region(id, updates) {
+    return patch_row("operating_context_regions", id, updates, "update");
+}
+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);
+}
+export async function server_create_operating_context_risk(row) {
+    return insert_with_creator("operating_context_risks", row);
+}
+export async function server_update_operating_context_risk(id, updates) {
+    return patch_row("operating_context_risks", id, updates, "update");
+}
+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();
+}

package/dist/helpers/plans.d.ts

@@ -1,8 +1,6 @@
-import { Database } from "../types/supabase";
 import { IPlan } from "../types/db";
 import { IWebResponseCompatible } from "../types/requests";
-import { SupabaseClient } from "@supabase/supabase-js";
 export declare function server_get_plans_by_herd(herd_id: number): Promise<IWebResponseCompatible<IPlan[]>>;
-export declare function server_get_plans_by_herd_ids(herd_ids: number[], client: SupabaseClient<Database>): Promise<IWebResponseCompatible<Record<number, IPlan[]>>>;
+export declare function server_get_plans_by_herd_ids(herd_ids: number[]): Promise<IWebResponseCompatible<Record<number, IPlan[]>>>;
 export declare function server_create_plans(plans: IPlan[]): Promise<IWebResponseCompatible<IPlan[]>>;
 export declare function server_delete_plans_by_ids(plan_ids: number[]): Promise<IWebResponseCompatible<boolean>>;

package/dist/helpers/plans.js

@@ -1,6 +1,7 @@
 "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
 export async function server_get_plans_by_herd(herd_id) {
     const supabase = await newServerClient();
@@ -20,24 +21,8 @@ export async function server_get_plans_by_herd(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, client) {
-    var _a;
-    if (herd_ids.length === 0) {
-        return IWebResponse.success({}).to_compatible();
-    }
-    const { data, error } = await client
-        .from("plans")
-        .select("*")
-        .in("herd_id", herd_ids)
-        .order("id", { ascending: true });
-    if (error) {
-        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(grouped).to_compatible();
+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) {

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

@@ -0,0 +1,5 @@
+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[]>>>;

package/dist/helpers/plans.queries.js

@@ -0,0 +1,20 @@
+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();
+    }
+    const { data, error } = await client
+        .from("plans")
+        .select("*")
+        .in("herd_id", herd_ids)
+        .order("id", { ascending: true });
+    if (error) {
+        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(grouped).to_compatible();
+}

package/dist/helpers/providers.d.ts

@@ -1,9 +1,7 @@
-import { Database } from "../types/supabase";
 import { IProvider } from "../types/db";
 import { IWebResponseCompatible } from "../types/requests";
-import { SupabaseClient } from "@supabase/supabase-js";
 export declare function server_get_providers_by_herd(herd_id: number): Promise<IWebResponseCompatible<IProvider[]>>;
-export declare function server_get_providers_by_herd_ids(herd_ids: number[], client: SupabaseClient<Database>): Promise<IWebResponseCompatible<Record<number, IProvider[]>>>;
+export declare function server_get_providers_by_herd_ids(herd_ids: number[]): Promise<IWebResponseCompatible<Record<number, IProvider[]>>>;
 export declare function server_create_provider(provider: Omit<IProvider, "id" | "created_at">): Promise<IWebResponseCompatible<IProvider>>;
 export declare function server_update_provider(provider_id: number, updates: Partial<Omit<IProvider, "id" | "created_at">>): Promise<IWebResponseCompatible<IProvider>>;
 export declare function server_delete_providers_by_ids(provider_ids: number[]): Promise<IWebResponseCompatible<boolean>>;

package/dist/helpers/providers.js

@@ -1,6 +1,7 @@
 "use server";
 import { newServerClient } from "../supabase/server";
 import { EnumWebResponse, IWebResponse, } from "../types/requests";
+import { get_providers_by_herd_ids_query } from "./herd_scoped.queries";
 // function that fetches the providers from our db given a herd id
 export async function server_get_providers_by_herd(herd_id) {
     const supabase = await newServerClient();
@@ -20,24 +21,8 @@ export async function server_get_providers_by_herd(herd_id) {
     }
 }
 // Fetches providers for many herds in one query, grouped by herd_id.
-export async function server_get_providers_by_herd_ids(herd_ids, client) {
-    var _a;
-    if (herd_ids.length === 0) {
-        return IWebResponse.success({}).to_compatible();
-    }
-    const { data, error } = await client
-        .from("providers")
-        .select("*")
-        .in("herd_id", herd_ids)
-        .order("id", { ascending: true });
-    if (error) {
-        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(grouped).to_compatible();
+export async function server_get_providers_by_herd_ids(herd_ids) {
+    return get_providers_by_herd_ids_query(await newServerClient(), herd_ids);
 }
 // function that creates a new provider in our db
 export async function server_create_provider(provider) {

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

@@ -0,0 +1,5 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { IProvider } from "../types/db";
+import { Database } from "../types/supabase";
+import { IWebResponseCompatible } from "../types/requests";
+export declare function get_providers_by_herd_ids_query(client: SupabaseClient<Database>, herd_ids: number[]): Promise<IWebResponseCompatible<Record<number, IProvider[]>>>;

package/dist/helpers/providers.queries.js

@@ -0,0 +1,20 @@
+import { EnumWebResponse, IWebResponse, } from "../types/requests";
+export async function get_providers_by_herd_ids_query(client, herd_ids) {
+    var _a;
+    if (herd_ids.length === 0) {
+        return IWebResponse.success({}).to_compatible();
+    }
+    const { data, error } = await client
+        .from("providers")
+        .select("*")
+        .in("herd_id", herd_ids)
+        .order("id", { ascending: true });
+    if (error) {
+        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(grouped).to_compatible();
+}

package/dist/helpers/pubsub_token_server.d.ts

@@ -1,7 +1,3 @@
-import { SupabaseClient } from "@supabase/supabase-js";
-import { Database } from "../types/supabase";
 import { IPubsubTokenMint } from "../types/pubsub_token";
 import { IWebResponseCompatible } from "../types/requests";
-export declare function server_mint_pubsub_token(options?: {
-    client?: SupabaseClient<Database>;
-}): Promise<IWebResponseCompatible<IPubsubTokenMint>>;
+export declare function server_mint_pubsub_token(): Promise<IWebResponseCompatible<IPubsubTokenMint>>;

package/dist/helpers/pubsub_token_server.js

@@ -1,7 +1,7 @@
 "use server";
 import { newServerClient } from "../supabase/server";
 import { mint_pubsub_token } from "./pubsub_token";
-export async function server_mint_pubsub_token(options) {
-    const client = options?.client ?? (await newServerClient());
+export async function server_mint_pubsub_token() {
+    const client = await newServerClient();
     return mint_pubsub_token(client);
 }

package/dist/helpers/realtime_topic_access.d.ts

@@ -0,0 +1,5 @@
+import { IClientAbilitiesTokenMint } from "../types/client_abilities_token";
+import { EnumJwtMintStatus } from "../types/jwt_mint";
+export declare function realtime_topic_ability(topic: string): string;
+export declare function can_access_realtime_topic(mint: IClientAbilitiesTokenMint | null | undefined, topic: string): boolean;
+export declare function filter_realtime_topics(status: EnumJwtMintStatus, mint: IClientAbilitiesTokenMint | null | undefined, topics: string[]): string[];

package/dist/helpers/realtime_topic_access.js

@@ -0,0 +1,55 @@
+import { can_herd_ability, } from "../types/client_abilities_token";
+import { EnumJwtMintStatus } from "../types/jwt_mint";
+export function realtime_topic_ability(topic) {
+    const channel = topic.slice(topic.indexOf("-") + 1);
+    switch (channel) {
+        case "contacts":
+            return "contacts.read";
+        case "maintenance_requests":
+            return "maintenance_requests.read";
+        case "herd_documents":
+            return "herd_documents.read";
+        case "device_documents":
+            return "device_documents.read";
+        case "user_documents":
+            return "user_documents.read";
+        case "operating_contexts":
+        case "operating_context_documents":
+            return "operating_contexts.read";
+        default:
+            return "content.read";
+    }
+}
+export function can_access_realtime_topic(mint, topic) {
+    if (topic === "versions_software_changes" ||
+        /^user_[0-9a-f-]+-documents$/i.test(topic)) {
+        return true;
+    }
+    const isProductDocuments = topic === "product_documents_changes";
+    const isAnalysis = topic === "analysis_jobs_changes" ||
+        topic === "analysis_tasks_changes";
+    const herd_match = /^(\d+)-/.exec(topic);
+    if (!isProductDocuments && !isAnalysis && !herd_match)
+        return true;
+    if (!mint?.token || mint.exp <= Math.floor(Date.now() / 1000))
+        return false;
+    if (isProductDocuments) {
+        return (mint.platform_superadmin ||
+            mint.herds.some((herd) => herd.abilities.includes("content.read")));
+    }
+    if (isAnalysis)
+        return mint.platform_superadmin;
+    if (!herd_match)
+        return true;
+    return can_herd_ability(mint, Number(herd_match[1]), realtime_topic_ability(topic));
+}
+export function filter_realtime_topics(status, mint, topics) {
+    if (status === EnumJwtMintStatus.IDLE)
+        return topics;
+    if (!mint?.token) {
+        return status === EnumJwtMintStatus.LOADING
+            ? topics.filter((topic) => can_access_realtime_topic(mint, topic))
+            : topics;
+    }
+    return topics.filter((topic) => can_access_realtime_topic(mint, topic));
+}

package/dist/helpers/session_summaries.d.ts

@@ -1,6 +1,5 @@
 import { ISessionSummary } from "../types/db";
 import { IWebResponseCompatible } from "../types/requests";
-import { SupabaseClient } from "@supabase/supabase-js";
-export declare function server_get_session_summaries_by_herd(herd_id: number, client?: SupabaseClient, min_duration_minutes_caller?: number, min_distance_meters_caller?: number, product_numbers_caller?: string[]): Promise<IWebResponseCompatible<ISessionSummary>>;
-export declare function server_get_session_summaries_by_device(device_id: number, client?: SupabaseClient, min_duration_minutes_caller?: number, min_distance_meters_caller?: number, product_numbers_caller?: string[]): Promise<IWebResponseCompatible<ISessionSummary>>;
-export declare function server_get_session_summaries_with_filters(herd_id?: number, device_id?: number, start_date?: string, end_date?: string, client?: SupabaseClient, min_duration_minutes_caller?: number, min_distance_meters_caller?: number, product_numbers_caller?: string[]): Promise<IWebResponseCompatible<ISessionSummary>>;
+export declare function server_get_session_summaries_by_herd(herd_id: number, min_duration_minutes_caller?: number, min_distance_meters_caller?: number, product_numbers_caller?: string[]): Promise<IWebResponseCompatible<ISessionSummary>>;
+export declare function server_get_session_summaries_by_device(device_id: number, min_duration_minutes_caller?: number, min_distance_meters_caller?: number, product_numbers_caller?: string[]): Promise<IWebResponseCompatible<ISessionSummary>>;
+export declare function server_get_session_summaries_with_filters(herd_id?: number, device_id?: number, start_date?: string, end_date?: string, min_duration_minutes_caller?: number, min_distance_meters_caller?: number, product_numbers_caller?: string[]): Promise<IWebResponseCompatible<ISessionSummary>>;

package/dist/helpers/session_summaries.js

@@ -1,60 +1,30 @@
 "use server";
 import { newServerClient } from "../supabase/server";
-import { IWebResponse, } from "../types/requests";
-export async function server_get_session_summaries_by_herd(herd_id, client, min_duration_minutes_caller, min_distance_meters_caller, product_numbers_caller) {
-    const supabase = client || (await newServerClient());
-    const { data, error } = await supabase.rpc("get_session_summaries", {
-        start_date_caller: undefined,
-        end_date_caller: undefined,
-        device_id_caller: undefined,
-        herd_id_caller: herd_id,
+import { get_session_summaries_query } from "./session_summaries.queries";
+export async function server_get_session_summaries_by_herd(herd_id, min_duration_minutes_caller, min_distance_meters_caller, product_numbers_caller) {
+    return get_session_summaries_query(await newServerClient(), {
+        herd_id,
         min_duration_minutes_caller,
         min_distance_meters_caller,
         product_numbers_caller,
     });
-    if (error) {
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    if (!data) {
-        return IWebResponse.error("No session summary data returned").to_compatible();
-    }
-    return IWebResponse.success(data).to_compatible();
 }
-export async function server_get_session_summaries_by_device(device_id, client, min_duration_minutes_caller, min_distance_meters_caller, product_numbers_caller) {
-    const supabase = client || (await newServerClient());
-    const { data, error } = await supabase.rpc("get_session_summaries", {
-        start_date_caller: undefined,
-        end_date_caller: undefined,
-        device_id_caller: device_id,
-        herd_id_caller: undefined,
+export async function server_get_session_summaries_by_device(device_id, min_duration_minutes_caller, min_distance_meters_caller, product_numbers_caller) {
+    return get_session_summaries_query(await newServerClient(), {
+        device_id,
         min_duration_minutes_caller,
         min_distance_meters_caller,
         product_numbers_caller,
     });
-    if (error) {
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    if (!data) {
-        return IWebResponse.error("No session summary data returned").to_compatible();
-    }
-    return IWebResponse.success(data).to_compatible();
 }
-export async function server_get_session_summaries_with_filters(herd_id, device_id, start_date, end_date, client, min_duration_minutes_caller, min_distance_meters_caller, product_numbers_caller) {
-    const supabase = client || (await newServerClient());
-    const { data, error } = await supabase.rpc("get_session_summaries", {
-        start_date_caller: start_date || undefined,
-        end_date_caller: end_date || undefined,
-        device_id_caller: device_id || undefined,
-        herd_id_caller: herd_id || undefined,
+export async function server_get_session_summaries_with_filters(herd_id, device_id, start_date, end_date, min_duration_minutes_caller, min_distance_meters_caller, product_numbers_caller) {
+    return get_session_summaries_query(await newServerClient(), {
+        herd_id,
+        device_id,
+        start_date,
+        end_date,
         min_duration_minutes_caller,
         min_distance_meters_caller,
         product_numbers_caller,
     });
-    if (error) {
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    if (!data) {
-        return IWebResponse.error("No session summary data returned").to_compatible();
-    }
-    return IWebResponse.success(data).to_compatible();
 }

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

@@ -0,0 +1,14 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { ISessionSummary } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+interface SessionSummaryFilters {
+    herd_id?: number;
+    device_id?: number;
+    start_date?: string;
+    end_date?: string;
+    min_duration_minutes_caller?: number;
+    min_distance_meters_caller?: number;
+    product_numbers_caller?: string[];
+}
+export declare function get_session_summaries_query(client: SupabaseClient, filters: SessionSummaryFilters): Promise<IWebResponseCompatible<ISessionSummary>>;
+export {};

package/dist/helpers/session_summaries.queries.js

@@ -0,0 +1,19 @@
+import { IWebResponse } from "../types/requests";
+export async function get_session_summaries_query(client, filters) {
+    const { data, error } = await client.rpc("get_session_summaries", {
+        start_date_caller: filters.start_date || undefined,
+        end_date_caller: filters.end_date || undefined,
+        device_id_caller: filters.device_id ?? undefined,
+        herd_id_caller: filters.herd_id ?? undefined,
+        min_duration_minutes_caller: filters.min_duration_minutes_caller,
+        min_distance_meters_caller: filters.min_distance_meters_caller,
+        product_numbers_caller: filters.product_numbers_caller,
+    });
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error("No session summary data returned").to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}

package/dist/helpers/sessions.d.ts

@@ -1,17 +1,16 @@
 import { ISessionWithCoordinates, ISessionUsageOverTime, IEventAndTagsPrettyLocation, ISession, SessionInsert, SessionUpdate } from "../types/db";
 import { IWebResponseCompatible } from "../types/requests";
-import { SupabaseClient } from "@supabase/supabase-js";
-export declare function server_get_session_by_id(sessionId: number, client?: SupabaseClient): Promise<IWebResponseCompatible<ISessionWithCoordinates | null>>;
+export declare function server_get_session_by_id(sessionId: number): Promise<IWebResponseCompatible<ISessionWithCoordinates | null>>;
 /** Existing sessions within tolerance of start/end timestamps. */
-export declare function server_match_sessions(deviceId: number, timestampStart: string, timestampEnd: string, toleranceSec: number, client?: SupabaseClient): Promise<IWebResponseCompatible<ISession[]>>;
-export declare function server_get_session_usage_over_time_by_herd(herd_id: number, client?: SupabaseClient, min_duration_minutes_caller?: number, min_distance_meters_caller?: number, product_numbers_caller?: string[]): Promise<IWebResponseCompatible<ISessionUsageOverTime>>;
-export declare function server_get_session_usage_over_time_by_device(device_id: number, client?: SupabaseClient, min_duration_minutes_caller?: number, min_distance_meters_caller?: number, product_numbers_caller?: string[]): Promise<IWebResponseCompatible<ISessionUsageOverTime>>;
+export declare function server_match_sessions(deviceId: number, timestampStart: string, timestampEnd: string, toleranceSec: number): Promise<IWebResponseCompatible<ISession[]>>;
+export declare function server_get_session_usage_over_time_by_herd(herd_id: number, min_duration_minutes_caller?: number, min_distance_meters_caller?: number, product_numbers_caller?: string[]): Promise<IWebResponseCompatible<ISessionUsageOverTime>>;
+export declare function server_get_session_usage_over_time_by_device(device_id: number, min_duration_minutes_caller?: number, min_distance_meters_caller?: number, product_numbers_caller?: string[]): Promise<IWebResponseCompatible<ISessionUsageOverTime>>;
 export declare function server_get_events_and_tags_by_session_id(sessionId: number, limit?: number, offset?: number): Promise<IWebResponseCompatible<IEventAndTagsPrettyLocation[]>>;
-export declare function server_insert_session(sessions: SessionInsert | SessionInsert[], client?: SupabaseClient): Promise<IWebResponseCompatible<ISession[]>>;
+export declare function server_insert_session(sessions: SessionInsert | SessionInsert[]): Promise<IWebResponseCompatible<ISession[]>>;
 export declare function server_update_session(sessions: (SessionUpdate & {
     id: number;
 }) | (SessionUpdate & {
     id: number;
-})[], client?: SupabaseClient): Promise<IWebResponseCompatible<ISession[]>>;
+})[]): Promise<IWebResponseCompatible<ISession[]>>;
 /** Artifact IDs for a session (same device, overlapping session interval). Empty if session or timestamps missing. */
-export declare function server_get_artifact_ids_for_session(sessionId: number, client?: SupabaseClient): Promise<IWebResponseCompatible<number[]>>;
+export declare function server_get_artifact_ids_for_session(sessionId: number): Promise<IWebResponseCompatible<number[]>>;