@adventurelabs/scout-core 1.5.5 → 2.0.1

package/dist/helpers/sensor_poses_server.d.ts

@@ -0,0 +1,98 @@
+import { SensorPoseInsert, SensorPoseUpdate } from "../types/db";
+import { get_sensor_poses_by_part_id } from "./sensor_poses";
+export declare function server_get_sensor_poses_by_part_id(part_id: number, options?: Parameters<typeof get_sensor_poses_by_part_id>[2]): Promise<import("../types").IWebResponseCompatible<{
+    active_processing_modality: string | null;
+    active_recording_modality: string | null;
+    id: number;
+    inserted_at: string;
+    origin_heading: number | null;
+    origin_height: number | null;
+    origin_location: unknown;
+    origin_pitch: number | null;
+    origin_roll: number | null;
+    part_id: number;
+    sensor_pitch: number | null;
+    sensor_roll: number | null;
+    sensor_yaw: number | null;
+    timestamp_observation: string;
+}[]>>;
+export declare function server_get_sensor_pose_by_id(sensor_pose_id: number): Promise<import("../types").IWebResponseCompatible<{
+    active_processing_modality: string | null;
+    active_recording_modality: string | null;
+    id: number;
+    inserted_at: string;
+    origin_heading: number | null;
+    origin_height: number | null;
+    origin_location: unknown;
+    origin_pitch: number | null;
+    origin_roll: number | null;
+    part_id: number;
+    sensor_pitch: number | null;
+    sensor_roll: number | null;
+    sensor_yaw: number | null;
+    timestamp_observation: string;
+} | null>>;
+export declare function server_create_sensor_pose(row: SensorPoseInsert): Promise<import("../types").IWebResponseCompatible<{
+    active_processing_modality: string | null;
+    active_recording_modality: string | null;
+    id: number;
+    inserted_at: string;
+    origin_heading: number | null;
+    origin_height: number | null;
+    origin_location: unknown;
+    origin_pitch: number | null;
+    origin_roll: number | null;
+    part_id: number;
+    sensor_pitch: number | null;
+    sensor_roll: number | null;
+    sensor_yaw: number | null;
+    timestamp_observation: string;
+} | null>>;
+export declare function server_create_sensor_poses(rows: SensorPoseInsert[]): Promise<import("../types").IWebResponseCompatible<{
+    active_processing_modality: string | null;
+    active_recording_modality: string | null;
+    id: number;
+    inserted_at: string;
+    origin_heading: number | null;
+    origin_height: number | null;
+    origin_location: unknown;
+    origin_pitch: number | null;
+    origin_roll: number | null;
+    part_id: number;
+    sensor_pitch: number | null;
+    sensor_roll: number | null;
+    sensor_yaw: number | null;
+    timestamp_observation: string;
+}[]>>;
+export declare function server_update_sensor_pose(sensor_pose_id: number, patch: SensorPoseUpdate): Promise<import("../types").IWebResponseCompatible<{
+    active_processing_modality: string | null;
+    active_recording_modality: string | null;
+    id: number;
+    inserted_at: string;
+    origin_heading: number | null;
+    origin_height: number | null;
+    origin_location: unknown;
+    origin_pitch: number | null;
+    origin_roll: number | null;
+    part_id: number;
+    sensor_pitch: number | null;
+    sensor_roll: number | null;
+    sensor_yaw: number | null;
+    timestamp_observation: string;
+} | null>>;
+export declare function server_delete_sensor_pose(sensor_pose_id: number): Promise<import("../types").IWebResponseCompatible<{
+    active_processing_modality: string | null;
+    active_recording_modality: string | null;
+    id: number;
+    inserted_at: string;
+    origin_heading: number | null;
+    origin_height: number | null;
+    origin_location: unknown;
+    origin_pitch: number | null;
+    origin_roll: number | null;
+    part_id: number;
+    sensor_pitch: number | null;
+    sensor_roll: number | null;
+    sensor_yaw: number | null;
+    timestamp_observation: string;
+} | null>>;

package/dist/helpers/sensor_poses_server.js

@@ -0,0 +1,26 @@
+import { newServerClient } from "../supabase/server";
+import { create_sensor_pose, create_sensor_poses, delete_sensor_pose, get_sensor_pose_by_id, get_sensor_poses_by_part_id, update_sensor_pose, } from "./sensor_poses";
+export async function server_get_sensor_poses_by_part_id(part_id, options) {
+    const client = await newServerClient();
+    return get_sensor_poses_by_part_id(client, part_id, options);
+}
+export async function server_get_sensor_pose_by_id(sensor_pose_id) {
+    const client = await newServerClient();
+    return get_sensor_pose_by_id(client, sensor_pose_id);
+}
+export async function server_create_sensor_pose(row) {
+    const client = await newServerClient();
+    return create_sensor_pose(client, row);
+}
+export async function server_create_sensor_poses(rows) {
+    const client = await newServerClient();
+    return create_sensor_poses(client, rows);
+}
+export async function server_update_sensor_pose(sensor_pose_id, patch) {
+    const client = await newServerClient();
+    return update_sensor_pose(client, sensor_pose_id, patch);
+}
+export async function server_delete_sensor_pose(sensor_pose_id) {
+    const client = await newServerClient();
+    return delete_sensor_pose(client, sensor_pose_id);
+}

package/dist/helpers/session_incidents_server.d.ts

@@ -0,0 +1,106 @@
+import { SessionIncidentInsert, SessionIncidentUpdate } from "../types/db";
+export declare function server_get_session_incidents_by_session_id(session_id: number): Promise<import("../types").IWebResponseCompatible<{
+    additional_details: import("../types").Json | null;
+    additional_details_version: number | null;
+    created_at: string;
+    created_by: string | null;
+    description: string | null;
+    device_altitude: number | null;
+    device_battery_percentage: number | null;
+    device_battery_time_remaining: string | null;
+    device_battery_volts: number | null;
+    device_location: unknown;
+    device_mode: string | null;
+    device_speed: number | null;
+    id: number;
+    incident_type: import("../types").Database["public"]["Enums"]["session_incident_type"] | null;
+    operator: string | null;
+    photo: string | null;
+    session_id: number;
+    updated_at: string;
+    updated_by: string | null;
+}[]>>;
+export declare function server_get_session_incident_by_id(incident_id: number): Promise<import("../types").IWebResponseCompatible<{
+    additional_details: import("../types").Json | null;
+    additional_details_version: number | null;
+    created_at: string;
+    created_by: string | null;
+    description: string | null;
+    device_altitude: number | null;
+    device_battery_percentage: number | null;
+    device_battery_time_remaining: string | null;
+    device_battery_volts: number | null;
+    device_location: unknown;
+    device_mode: string | null;
+    device_speed: number | null;
+    id: number;
+    incident_type: import("../types").Database["public"]["Enums"]["session_incident_type"] | null;
+    operator: string | null;
+    photo: string | null;
+    session_id: number;
+    updated_at: string;
+    updated_by: string | null;
+} | null>>;
+export declare function server_create_session_incident(row: SessionIncidentInsert): Promise<import("../types").IWebResponseCompatible<{
+    additional_details: import("../types").Json | null;
+    additional_details_version: number | null;
+    created_at: string;
+    created_by: string | null;
+    description: string | null;
+    device_altitude: number | null;
+    device_battery_percentage: number | null;
+    device_battery_time_remaining: string | null;
+    device_battery_volts: number | null;
+    device_location: unknown;
+    device_mode: string | null;
+    device_speed: number | null;
+    id: number;
+    incident_type: import("../types").Database["public"]["Enums"]["session_incident_type"] | null;
+    operator: string | null;
+    photo: string | null;
+    session_id: number;
+    updated_at: string;
+    updated_by: string | null;
+} | null>>;
+export declare function server_update_session_incident(incident_id: number, patch: SessionIncidentUpdate): Promise<import("../types").IWebResponseCompatible<{
+    additional_details: import("../types").Json | null;
+    additional_details_version: number | null;
+    created_at: string;
+    created_by: string | null;
+    description: string | null;
+    device_altitude: number | null;
+    device_battery_percentage: number | null;
+    device_battery_time_remaining: string | null;
+    device_battery_volts: number | null;
+    device_location: unknown;
+    device_mode: string | null;
+    device_speed: number | null;
+    id: number;
+    incident_type: import("../types").Database["public"]["Enums"]["session_incident_type"] | null;
+    operator: string | null;
+    photo: string | null;
+    session_id: number;
+    updated_at: string;
+    updated_by: string | null;
+} | null>>;
+export declare function server_delete_session_incident(incident_id: number): Promise<import("../types").IWebResponseCompatible<{
+    additional_details: import("../types").Json | null;
+    additional_details_version: number | null;
+    created_at: string;
+    created_by: string | null;
+    description: string | null;
+    device_altitude: number | null;
+    device_battery_percentage: number | null;
+    device_battery_time_remaining: string | null;
+    device_battery_volts: number | null;
+    device_location: unknown;
+    device_mode: string | null;
+    device_speed: number | null;
+    id: number;
+    incident_type: import("../types").Database["public"]["Enums"]["session_incident_type"] | null;
+    operator: string | null;
+    photo: string | null;
+    session_id: number;
+    updated_at: string;
+    updated_by: string | null;
+} | null>>;

package/dist/helpers/session_incidents_server.js

@@ -0,0 +1,22 @@
+import { newServerClient } from "../supabase/server";
+import { create_session_incident, delete_session_incident, get_session_incident_by_id, get_session_incidents_by_session_id, update_session_incident, } from "./session_incidents";
+export async function server_get_session_incidents_by_session_id(session_id) {
+    const client = await newServerClient();
+    return get_session_incidents_by_session_id(client, session_id);
+}
+export async function server_get_session_incident_by_id(incident_id) {
+    const client = await newServerClient();
+    return get_session_incident_by_id(client, incident_id);
+}
+export async function server_create_session_incident(row) {
+    const client = await newServerClient();
+    return create_session_incident(client, row);
+}
+export async function server_update_session_incident(incident_id, patch) {
+    const client = await newServerClient();
+    return update_session_incident(client, incident_id, patch);
+}
+export async function server_delete_session_incident(incident_id) {
+    const client = await newServerClient();
+    return delete_session_incident(client, incident_id);
+}

package/dist/helpers/session_summaries.d.ts

@@ -1,5 +1,7 @@
 import { ISessionSummary } from "../types/db";
 import { IWebResponseCompatible } from "../types/requests";
+import { SessionSummaryFilters } from "./session_summaries.queries";
+export declare function server_get_session_summaries(filters: SessionSummaryFilters): 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,30 +1,14 @@
-"use server";
 import { newServerClient } from "../supabase/server";
-import { get_session_summaries_query } from "./session_summaries.queries";
+import { get_session_summaries_by_device_query, get_session_summaries_by_herd_query, get_session_summaries_query, get_session_summaries_with_filters_query, } from "./session_summaries.queries";
+export async function server_get_session_summaries(filters) {
+    return get_session_summaries_query(await newServerClient(), filters);
+}
 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,
-    });
+    return get_session_summaries_by_herd_query(await newServerClient(), herd_id, min_duration_minutes_caller, min_distance_meters_caller, product_numbers_caller);
 }
 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,
-    });
+    return get_session_summaries_by_device_query(await newServerClient(), device_id, min_duration_minutes_caller, min_distance_meters_caller, product_numbers_caller);
 }
 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,
-    });
+    return get_session_summaries_with_filters_query(await newServerClient(), herd_id, device_id, start_date, end_date, min_duration_minutes_caller, min_distance_meters_caller, product_numbers_caller);
 }

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

@@ -1,7 +1,8 @@
 import { SupabaseClient } from "@supabase/supabase-js";
 import { ISessionSummary } from "../types/db";
 import { IWebResponseCompatible } from "../types/requests";
-interface SessionSummaryFilters {
+import { Database } from "../types/supabase";
+export interface SessionSummaryFilters {
     herd_id?: number;
     device_id?: number;
     start_date?: string;
@@ -10,5 +11,7 @@ interface SessionSummaryFilters {
     min_distance_meters_caller?: number;
     product_numbers_caller?: string[];
 }
-export declare function get_session_summaries_query(client: SupabaseClient, filters: SessionSummaryFilters): Promise<IWebResponseCompatible<ISessionSummary>>;
-export {};
+export declare function get_session_summaries_query(client: SupabaseClient<Database>, filters: SessionSummaryFilters): Promise<IWebResponseCompatible<ISessionSummary>>;
+export declare function get_session_summaries_by_herd_query(client: SupabaseClient<Database>, herd_id: number, min_duration_minutes_caller?: number, min_distance_meters_caller?: number, product_numbers_caller?: string[]): Promise<IWebResponseCompatible<ISessionSummary>>;
+export declare function get_session_summaries_by_device_query(client: SupabaseClient<Database>, device_id: number, min_duration_minutes_caller?: number, min_distance_meters_caller?: number, product_numbers_caller?: string[]): Promise<IWebResponseCompatible<ISessionSummary>>;
+export declare function get_session_summaries_with_filters_query(client: SupabaseClient<Database>, 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.queries.js

@@ -17,3 +17,30 @@ export async function get_session_summaries_query(client, filters) {
     }
     return IWebResponse.success(data).to_compatible();
 }
+export async function get_session_summaries_by_herd_query(client, herd_id, min_duration_minutes_caller, min_distance_meters_caller, product_numbers_caller) {
+    return get_session_summaries_query(client, {
+        herd_id,
+        min_duration_minutes_caller,
+        min_distance_meters_caller,
+        product_numbers_caller,
+    });
+}
+export async function get_session_summaries_by_device_query(client, device_id, min_duration_minutes_caller, min_distance_meters_caller, product_numbers_caller) {
+    return get_session_summaries_query(client, {
+        device_id,
+        min_duration_minutes_caller,
+        min_distance_meters_caller,
+        product_numbers_caller,
+    });
+}
+export async function get_session_summaries_with_filters_query(client, herd_id, device_id, start_date, end_date, min_duration_minutes_caller, min_distance_meters_caller, product_numbers_caller) {
+    return get_session_summaries_query(client, {
+        herd_id,
+        device_id,
+        start_date,
+        end_date,
+        min_duration_minutes_caller,
+        min_distance_meters_caller,
+        product_numbers_caller,
+    });
+}

package/dist/helpers/sessions.js

@@ -1,142 +1,28 @@
-"use server";
 import { newServerClient } from "../supabase/server";
-import { EnumWebResponse, IWebResponse, } from "../types/requests";
-import { generateSignedUrlsBatchWithClient } from "./storage_internal";
-import { isNonEmptyStorageFilePath } from "./storagePath";
-import { get_session_usage_over_time_by_herd_query } from "./sessions.queries";
-// Get session by ID with coordinates
+import { get_artifact_ids_for_session_query, get_events_and_tags_by_session_id_query, get_session_by_id_query, get_session_usage_over_time_by_device_query, get_session_usage_over_time_by_herd_query, insert_session_query, match_sessions_query, update_session_query, } from "./sessions.queries";
 export async function server_get_session_by_id(sessionId) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase.rpc("get_session_by_id", {
-        session_id_caller: sessionId,
-    });
-    if (error) {
-        console.warn("Error fetching session by id:", error.message);
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
-    }
-    return IWebResponse.success(data && data.length > 0 ? data[0] : null).to_compatible();
+    return get_session_by_id_query(await newServerClient(), sessionId);
 }
 /** Existing sessions within tolerance of start/end timestamps. */
 export async function server_match_sessions(deviceId, timestampStart, timestampEnd, toleranceSec) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase.rpc("match_sessions", {
-        device_id_caller: deviceId,
-        timestamp_start_caller: timestampStart,
-        timestamp_end_caller: timestampEnd,
-        tolerance_sec_caller: toleranceSec,
-    });
-    if (error) {
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    return IWebResponse.success(data || []).to_compatible();
+    return match_sessions_query(await newServerClient(), deviceId, timestampStart, timestampEnd, toleranceSec);
 }
-// Get session usage over time by herd
 export async function server_get_session_usage_over_time_by_herd(herd_id, min_duration_minutes_caller, min_distance_meters_caller, product_numbers_caller) {
     return get_session_usage_over_time_by_herd_query(await newServerClient(), herd_id, min_duration_minutes_caller, min_distance_meters_caller, product_numbers_caller);
 }
-// Get session usage over time by device
 export async function server_get_session_usage_over_time_by_device(device_id, min_duration_minutes_caller, min_distance_meters_caller, product_numbers_caller) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase.rpc("get_session_usage_over_time", {
-        start_date_caller: undefined,
-        end_date_caller: undefined,
-        device_id_caller: device_id,
-        herd_id_caller: undefined,
-        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 usage data returned").to_compatible();
-    }
-    return IWebResponse.success(data).to_compatible();
+    return get_session_usage_over_time_by_device_query(await newServerClient(), device_id, min_duration_minutes_caller, min_distance_meters_caller, product_numbers_caller);
 }
-// Get events with tags by session id using RPC function
 export async function server_get_events_and_tags_by_session_id(sessionId, limit = 50, offset = 0) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase.rpc("get_events_and_tags_for_session", {
-        session_id_caller: sessionId,
-        limit_caller: limit,
-        offset_caller: offset,
-    });
-    if (error) {
-        console.warn("Error fetching events and tags by session id:", error.message);
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: [],
-        };
-    }
-    const eventData = (data || []);
-    const filePaths = eventData
-        .map((event) => event.file_path)
-        .filter(isNonEmptyStorageFilePath);
-    let eventsWithSignedUrls = eventData;
-    if (filePaths.length > 0) {
-        const signedUrls = await generateSignedUrlsBatchWithClient(supabase, filePaths);
-        const urlMap = new Map();
-        filePaths.forEach((path, index) => {
-            urlMap.set(path, signedUrls[index]);
-        });
-        eventsWithSignedUrls = eventData.map((event) => ({
-            ...event,
-            media_url: isNonEmptyStorageFilePath(event.file_path)
-                ? urlMap.get(event.file_path) ?? null
-                : null,
-        }));
-    }
-    return IWebResponse.success(eventsWithSignedUrls).to_compatible();
+    return get_events_and_tags_by_session_id_query(await newServerClient(), sessionId, limit, offset);
 }
-// Insert new sessions (accepts array for batch operations)
 export async function server_insert_session(sessions) {
-    const supabase = await newServerClient();
-    const sessionsArray = Array.isArray(sessions) ? sessions : [sessions];
-    const { data, error } = await supabase
-        .from("sessions")
-        .insert(sessionsArray)
-        .select("*");
-    if (error) {
-        console.warn("Error inserting sessions:", error.message);
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
-    }
-    return IWebResponse.success(data || []).to_compatible();
+    return insert_session_query(await newServerClient(), sessions);
 }
-// Update existing sessions (accepts array for batch operations)
-// Each session in the array must include an 'id' field
 export async function server_update_session(sessions) {
-    const supabase = await newServerClient();
-    const sessionsArray = Array.isArray(sessions) ? sessions : [sessions];
-    const updatedSessions = [];
-    for (const session of sessionsArray) {
-        const { id, ...updateData } = session;
-        delete updateData.inserted_at;
-        const { data, error } = await supabase
-            .from("sessions")
-            .update(updateData)
-            .eq("id", id)
-            .select("*")
-            .single();
-        if (error) {
-            console.warn("Error updating session:", error.message);
-            return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
-        }
-        if (data)
-            updatedSessions.push(data);
-    }
-    return IWebResponse.success(updatedSessions).to_compatible();
+    return update_session_query(await newServerClient(), sessions);
 }
 /** Artifact IDs for a session (same device, overlapping session interval). Empty if session or timestamps missing. */
 export async function server_get_artifact_ids_for_session(sessionId) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase.rpc("get_artifact_ids_for_session", {
-        session_id_caller: sessionId,
-    });
-    if (error) {
-        console.warn("Error fetching artifact IDs for session:", error.message);
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
-    }
-    return IWebResponse.success(Array.isArray(data) ? data : []).to_compatible();
+    return get_artifact_ids_for_session_query(await newServerClient(), sessionId);
 }

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

@@ -1,4 +1,16 @@
 import { SupabaseClient } from "@supabase/supabase-js";
-import { ISessionUsageOverTime } from "../types/db";
+import { IEventAndTagsPrettyLocation, ISession, ISessionUsageOverTime, ISessionWithCoordinates, SessionInsert, SessionUpdate } from "../types/db";
 import { IWebResponseCompatible } from "../types/requests";
-export declare function get_session_usage_over_time_by_herd_query(client: SupabaseClient, herd_id: number, min_duration_minutes_caller?: number, min_distance_meters_caller?: number, product_numbers_caller?: string[]): Promise<IWebResponseCompatible<ISessionUsageOverTime>>;
+import { Database } from "../types/supabase";
+export declare function get_session_by_id_query(client: SupabaseClient<Database>, sessionId: number): Promise<IWebResponseCompatible<ISessionWithCoordinates | null>>;
+export declare function match_sessions_query(client: SupabaseClient<Database>, deviceId: number, timestampStart: string, timestampEnd: string, toleranceSec: number): Promise<IWebResponseCompatible<ISession[]>>;
+export declare function get_session_usage_over_time_by_herd_query(client: SupabaseClient<Database>, herd_id: number, min_duration_minutes_caller?: number, min_distance_meters_caller?: number, product_numbers_caller?: string[]): Promise<IWebResponseCompatible<ISessionUsageOverTime>>;
+export declare function get_session_usage_over_time_by_device_query(client: SupabaseClient<Database>, device_id: number, min_duration_minutes_caller?: number, min_distance_meters_caller?: number, product_numbers_caller?: string[]): Promise<IWebResponseCompatible<ISessionUsageOverTime>>;
+export declare function get_events_and_tags_by_session_id_query(client: SupabaseClient<Database>, sessionId: number, limit?: number, offset?: number): Promise<IWebResponseCompatible<IEventAndTagsPrettyLocation[]>>;
+export declare function insert_session_query(client: SupabaseClient<Database>, sessions: SessionInsert | SessionInsert[]): Promise<IWebResponseCompatible<ISession[]>>;
+export declare function update_session_query(client: SupabaseClient<Database>, sessions: (SessionUpdate & {
+    id: number;
+}) | (SessionUpdate & {
+    id: number;
+})[]): Promise<IWebResponseCompatible<ISession[]>>;
+export declare function get_artifact_ids_for_session_query(client: SupabaseClient<Database>, sessionId: number): Promise<IWebResponseCompatible<number[]>>;

package/dist/helpers/sessions.queries.js

@@ -1,4 +1,27 @@
-import { IWebResponse } from "../types/requests";
+import { EnumWebResponse, IWebResponse, } from "../types/requests";
+import { addEventMediaUrls } from "./media_urls";
+export async function get_session_by_id_query(client, sessionId) {
+    const { data, error } = await client.rpc("get_session_by_id", {
+        session_id_caller: sessionId,
+    });
+    if (error) {
+        console.warn("Error fetching session by id:", error.message);
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    return IWebResponse.success(data && data.length > 0 ? data[0] : null).to_compatible();
+}
+export async function match_sessions_query(client, deviceId, timestampStart, timestampEnd, toleranceSec) {
+    const { data, error } = await client.rpc("match_sessions", {
+        device_id_caller: deviceId,
+        timestamp_start_caller: timestampStart,
+        timestamp_end_caller: timestampEnd,
+        tolerance_sec_caller: toleranceSec,
+    });
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    return IWebResponse.success(data || []).to_compatible();
+}
 async function get_session_usage_over_time_query(client, herd_id, device_id, min_duration_minutes_caller, min_distance_meters_caller, product_numbers_caller) {
     const { data, error } = await client.rpc("get_session_usage_over_time", {
         start_date_caller: undefined,
@@ -20,3 +43,67 @@ async function get_session_usage_over_time_query(client, herd_id, device_id, min
 export function get_session_usage_over_time_by_herd_query(client, herd_id, min_duration_minutes_caller, min_distance_meters_caller, product_numbers_caller) {
     return get_session_usage_over_time_query(client, herd_id, undefined, min_duration_minutes_caller, min_distance_meters_caller, product_numbers_caller);
 }
+export function get_session_usage_over_time_by_device_query(client, device_id, min_duration_minutes_caller, min_distance_meters_caller, product_numbers_caller) {
+    return get_session_usage_over_time_query(client, undefined, device_id, min_duration_minutes_caller, min_distance_meters_caller, product_numbers_caller);
+}
+export async function get_events_and_tags_by_session_id_query(client, sessionId, limit = 50, offset = 0) {
+    const { data, error } = await client.rpc("get_events_and_tags_for_session", {
+        session_id_caller: sessionId,
+        limit_caller: limit,
+        offset_caller: offset,
+    });
+    if (error) {
+        console.warn("Error fetching events and tags by session id:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: [],
+        };
+    }
+    const eventData = (data || []);
+    const eventsWithSignedUrls = await addEventMediaUrls(client, eventData);
+    return IWebResponse.success(eventsWithSignedUrls).to_compatible();
+}
+export async function insert_session_query(client, sessions) {
+    const sessionsArray = Array.isArray(sessions) ? sessions : [sessions];
+    const { data, error } = await client
+        .from("sessions")
+        .insert(sessionsArray)
+        .select("*");
+    if (error) {
+        console.warn("Error inserting sessions:", error.message);
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
+    }
+    return IWebResponse.success(data || []).to_compatible();
+}
+export async function update_session_query(client, sessions) {
+    const sessionsArray = Array.isArray(sessions) ? sessions : [sessions];
+    const updatedSessions = [];
+    for (const session of sessionsArray) {
+        const { id, ...updateData } = session;
+        delete updateData.inserted_at;
+        const { data, error } = await client
+            .from("sessions")
+            .update(updateData)
+            .eq("id", id)
+            .select("*")
+            .single();
+        if (error) {
+            console.warn("Error updating session:", error.message);
+            return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
+        }
+        if (data)
+            updatedSessions.push(data);
+    }
+    return IWebResponse.success(updatedSessions).to_compatible();
+}
+export async function get_artifact_ids_for_session_query(client, sessionId) {
+    const { data, error } = await client.rpc("get_artifact_ids_for_session", {
+        session_id_caller: sessionId,
+    });
+    if (error) {
+        console.warn("Error fetching artifact IDs for session:", error.message);
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
+    }
+    return IWebResponse.success(Array.isArray(data) ? data : []).to_compatible();
+}

package/dist/helpers/storage.js

@@ -1,4 +1,3 @@
-"use server";
 import { newServerClient } from "../supabase/server";
 import { generateSignedUrlsBatchWithClient, generateSignedUrlWithClient, } from "./storage_internal";
 export async function generateSignedUrl(filePath, expiresIn) {

package/dist/helpers/supabase_auth.d.ts

@@ -0,0 +1,6 @@
+import type { AuthChangeEvent, Session, SupabaseClient } from "@supabase/supabase-js";
+import type { Database } from "../types/supabase";
+type AuthListener = (event: AuthChangeEvent, session: Session | null) => void;
+export declare function subscribeToSupabaseAuth(client: SupabaseClient<Database>, listener: AuthListener): () => void;
+export declare function refreshRealtimeAuth(client: SupabaseClient<Database>): Promise<void>;
+export {};