@adventurelabs/scout-core 1.5.4 → 2.0.0

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 {};

package/dist/helpers/supabase_auth.js

@@ -0,0 +1,37 @@
+const authListeners = new WeakMap();
+const realtimeAuthRequests = new WeakMap();
+export function subscribeToSupabaseAuth(client, listener) {
+    let entry = authListeners.get(client);
+    if (!entry) {
+        const listeners = new Set([listener]);
+        const { data: { subscription }, } = client.auth.onAuthStateChange((event, session) => {
+            listeners.forEach((currentListener) => currentListener(event, session));
+        });
+        entry = {
+            listeners,
+            unsubscribe: () => subscription.unsubscribe(),
+        };
+        authListeners.set(client, entry);
+    }
+    else {
+        entry.listeners.add(listener);
+    }
+    return () => {
+        entry?.listeners.delete(listener);
+        if (entry?.listeners.size === 0) {
+            entry.unsubscribe();
+            authListeners.delete(client);
+        }
+    };
+}
+export function refreshRealtimeAuth(client) {
+    const currentRequest = realtimeAuthRequests.get(client);
+    if (currentRequest) {
+        return currentRequest;
+    }
+    const request = client.realtime
+        .setAuth()
+        .finally(() => realtimeAuthRequests.delete(client));
+    realtimeAuthRequests.set(client, request);
+    return request;
+}

package/dist/helpers/tags.d.ts

@@ -1,6 +1,5 @@
 import { IEventAndTagsPrettyLocation, IMinimalSubjectForArtifact, ITag, ITagPrettyLocation } from "../types/db";
 import { IWebResponseCompatible } from "../types/requests";
-export declare function test_event_loading(device_id: number): Promise<boolean>;
 export declare function server_create_tags(tags: ITag[]): Promise<IWebResponseCompatible<ITag[]>>;
 export declare function server_delete_tags_by_ids(tag_ids: number[]): Promise<IWebResponseCompatible<boolean>>;
 export declare function server_update_tags(tags: ITag[]): Promise<IWebResponseCompatible<ITag[]>>;