@adventurelabs/scout-core 1.4.96 → 1.5.0

package/dist/helpers/sessions.js

@@ -1,29 +1,24 @@
 "use server";
 import { newServerClient } from "../supabase/server";
 import { EnumWebResponse, IWebResponse, } from "../types/requests";
-import { generateSignedUrlsBatch, } from "./storage";
+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
-export async function server_get_session_by_id(sessionId, client) {
-    const supabase = client || (await newServerClient());
+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 { status: EnumWebResponse.ERROR, msg: error.message, data: null };
     }
-    // The RPC returns an array, but we want a single session or null
-    const session = data && data.length > 0 ? data[0] : null;
-    return IWebResponse.success(session).to_compatible();
+    return IWebResponse.success(data && data.length > 0 ? data[0] : null).to_compatible();
 }
 /** Existing sessions within tolerance of start/end timestamps. */
-export async function server_match_sessions(deviceId, timestampStart, timestampEnd, toleranceSec, client) {
-    const supabase = client || (await newServerClient());
+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,
@@ -36,28 +31,12 @@ export async function server_match_sessions(deviceId, timestampStart, timestampE
     return IWebResponse.success(data || []).to_compatible();
 }
 // Get session usage over time by herd
-export async function server_get_session_usage_over_time_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_usage_over_time", {
-        start_date_caller: undefined,
-        end_date_caller: undefined,
-        device_id_caller: undefined,
-        herd_id_caller: 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 usage data returned").to_compatible();
-    }
-    return IWebResponse.success(data).to_compatible();
+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, client, min_duration_minutes_caller, min_distance_meters_caller, product_numbers_caller) {
-    const supabase = client || (await newServerClient());
+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,
@@ -97,7 +76,7 @@ export async function server_get_events_and_tags_by_session_id(sessionId, limit
         .filter(isNonEmptyStorageFilePath);
     let eventsWithSignedUrls = eventData;
     if (filePaths.length > 0) {
-        const signedUrls = await generateSignedUrlsBatch(filePaths, undefined, supabase);
+        const signedUrls = await generateSignedUrlsBatchWithClient(supabase, filePaths);
         const urlMap = new Map();
         filePaths.forEach((path, index) => {
             urlMap.set(path, signedUrls[index]);
@@ -112,8 +91,8 @@ export async function server_get_events_and_tags_by_session_id(sessionId, limit
     return IWebResponse.success(eventsWithSignedUrls).to_compatible();
 }
 // Insert new sessions (accepts array for batch operations)
-export async function server_insert_session(sessions, client) {
-    const supabase = client || (await newServerClient());
+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")
@@ -121,23 +100,18 @@ export async function server_insert_session(sessions, client) {
         .select("*");
     if (error) {
         console.warn("Error inserting sessions:", error.message);
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: [],
-        };
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
     }
     return IWebResponse.success(data || []).to_compatible();
 }
 // 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, client) {
-    const supabase = client || (await newServerClient());
+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;
-        // Remove fields that shouldn't be updated
         delete updateData.inserted_at;
         const { data, error } = await supabase
             .from("sessions")
@@ -147,31 +121,22 @@ export async function server_update_session(sessions, client) {
             .single();
         if (error) {
             console.warn("Error updating session:", error.message);
-            return {
-                status: EnumWebResponse.ERROR,
-                msg: error.message,
-                data: [],
-            };
+            return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
         }
-        if (data) {
+        if (data)
             updatedSessions.push(data);
-        }
     }
     return IWebResponse.success(updatedSessions).to_compatible();
 }
 /** 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, client) {
-    const supabase = client || (await newServerClient());
+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 { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
     }
     return IWebResponse.success(Array.isArray(data) ? data : []).to_compatible();
 }

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

@@ -0,0 +1,4 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { ISessionUsageOverTime } 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>>;

package/dist/helpers/sessions.queries.js

@@ -0,0 +1,22 @@
+import { IWebResponse } from "../types/requests";
+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,
+        end_date_caller: undefined,
+        device_id_caller: device_id,
+        herd_id_caller: 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 usage data returned").to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+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);
+}

package/dist/helpers/storage.d.ts

@@ -1,4 +1,2 @@
-import { SupabaseClient } from "@supabase/supabase-js";
-import { Database } from "../types/supabase";
-export declare function generateSignedUrl(filePath: string, expiresIn?: number, supabaseClient?: SupabaseClient<Database>): Promise<string | null>;
-export declare function generateSignedUrlsBatch(filePaths: string[], expiresIn?: number, supabaseClient?: SupabaseClient<Database>): Promise<(string | null)[]>;
+export declare function generateSignedUrl(filePath: string, expiresIn?: number): Promise<string | null>;
+export declare function generateSignedUrlsBatch(filePaths: string[], expiresIn?: number): Promise<(string | null)[]>;

package/dist/helpers/storage.js

@@ -1,58 +1,11 @@
 "use server";
 import { newServerClient } from "../supabase/server";
-import { SIGNED_URL_EXPIRATION_SECONDS } from "../constants/db";
-import { parseStorageFilePath } from "./storagePath";
-export async function generateSignedUrl(filePath, expiresIn = SIGNED_URL_EXPIRATION_SECONDS, supabaseClient) {
-    try {
-        const supabase = supabaseClient || (await newServerClient());
-        const parsed = parseStorageFilePath(filePath);
-        if (!parsed) {
-            console.error("Invalid file path:", filePath);
-            return null;
-        }
-        const { data, error } = await supabase.storage
-            .from(parsed.bucket)
-            .createSignedUrl(parsed.objectPath, expiresIn);
-        if (error) {
-            console.error("Error generating signed URL:", error.message);
-            return null;
-        }
-        return data.signedUrl;
-    }
-    catch (error) {
-        console.error("Error in generateSignedUrl:", error);
-        return null;
-    }
+import { generateSignedUrlsBatchWithClient, generateSignedUrlWithClient, } from "./storage_internal";
+export async function generateSignedUrl(filePath, expiresIn) {
+    const supabase = await newServerClient();
+    return generateSignedUrlWithClient(supabase, filePath, expiresIn);
 }
-export async function generateSignedUrlsBatch(filePaths, expiresIn = SIGNED_URL_EXPIRATION_SECONDS, supabaseClient) {
-    try {
-        const supabase = supabaseClient || (await newServerClient());
-        const signedUrlPromises = filePaths.map(async (filePath) => {
-            try {
-                const parsed = parseStorageFilePath(filePath);
-                if (!parsed) {
-                    console.error("Invalid file path:", filePath);
-                    return null;
-                }
-                const { data, error } = await supabase.storage
-                    .from(parsed.bucket)
-                    .createSignedUrl(parsed.objectPath, expiresIn);
-                if (error) {
-                    console.warn(`Error generating signed URL for ${filePath}:`, error.message);
-                    return null;
-                }
-                return data.signedUrl;
-            }
-            catch (error) {
-                console.warn(`Exception generating signed URL for ${filePath}:`, error);
-                return null;
-            }
-        });
-        const results = await Promise.all(signedUrlPromises);
-        return results;
-    }
-    catch (error) {
-        console.error("Error in generateSignedUrlsBatch:", error);
-        return new Array(filePaths.length).fill(null);
-    }
+export async function generateSignedUrlsBatch(filePaths, expiresIn) {
+    const supabase = await newServerClient();
+    return generateSignedUrlsBatchWithClient(supabase, filePaths, expiresIn);
 }

package/dist/helpers/storage_internal.d.ts

@@ -0,0 +1,4 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { Database } from "../types/supabase";
+export declare function generateSignedUrlsBatchWithClient(supabase: SupabaseClient<Database>, filePaths: string[], expiresIn?: number): Promise<(string | null)[]>;
+export declare function generateSignedUrlWithClient(supabase: SupabaseClient<Database>, filePath: string, expiresIn?: number): Promise<string | null>;

package/dist/helpers/storage_internal.js

@@ -0,0 +1,29 @@
+import { SIGNED_URL_EXPIRATION_SECONDS } from "../constants/db";
+import { parseStorageFilePath } from "./storagePath";
+export async function generateSignedUrlsBatchWithClient(supabase, filePaths, expiresIn = SIGNED_URL_EXPIRATION_SECONDS) {
+    return Promise.all(filePaths.map(async (filePath) => {
+        try {
+            const parsed = parseStorageFilePath(filePath);
+            if (!parsed) {
+                console.error("Invalid file path:", filePath);
+                return null;
+            }
+            const { data, error } = await supabase.storage
+                .from(parsed.bucket)
+                .createSignedUrl(parsed.objectPath, expiresIn);
+            if (error) {
+                console.warn(`Error generating signed URL for ${filePath}:`, error.message);
+                return null;
+            }
+            return data.signedUrl;
+        }
+        catch (error) {
+            console.warn(`Exception generating signed URL for ${filePath}:`, error);
+            return null;
+        }
+    }));
+}
+export async function generateSignedUrlWithClient(supabase, filePath, expiresIn = SIGNED_URL_EXPIRATION_SECONDS) {
+    const [signedUrl] = await generateSignedUrlsBatchWithClient(supabase, [filePath], expiresIn);
+    return signedUrl ?? null;
+}

package/dist/helpers/tags.js

@@ -2,7 +2,7 @@
 // add tag to db
 import { newServerClient } from "../supabase/server";
 import { EnumWebResponse, IWebResponse, } from "../types/requests";
-import { generateSignedUrlsBatch, generateSignedUrl, } from "./storage";
+import { generateSignedUrlsBatchWithClient, generateSignedUrlWithClient, } from "./storage_internal";
 import { isNonEmptyStorageFilePath } from "./storagePath";
 // Helper functions to extract coordinates from location field
 function extractLatitude(location) {
@@ -177,7 +177,7 @@ export async function server_get_more_events_with_tags_by_herd(herd_id, offset,
         .filter(isNonEmptyStorageFilePath);
     let eventsWithSignedUrls = filtered_data;
     if (filePaths.length > 0) {
-        const signedUrls = await generateSignedUrlsBatch(filePaths, undefined, supabase);
+        const signedUrls = await generateSignedUrlsBatchWithClient(supabase, filePaths, undefined);
         const urlMap = new Map();
         filePaths.forEach((path, index) => {
             urlMap.set(path, signedUrls[index]);
@@ -213,7 +213,7 @@ export async function server_get_events_and_tags_for_device(device_id, limit = 3
         .filter(isNonEmptyStorageFilePath);
     let eventsWithSignedUrls = eventData;
     if (filePaths.length > 0) {
-        const signedUrls = await generateSignedUrlsBatch(filePaths, undefined, supabase);
+        const signedUrls = await generateSignedUrlsBatchWithClient(supabase, filePaths, undefined);
         const urlMap = new Map();
         filePaths.forEach((path, index) => {
             urlMap.set(path, signedUrls[index]);
@@ -307,7 +307,7 @@ export async function server_get_events_and_tags_for_devices_batch(device_ids, l
     }
     // Generate all signed URLs at once
     const signedUrls = allFilePaths.length > 0
-        ? await generateSignedUrlsBatch(allFilePaths, undefined, supabase)
+        ? await generateSignedUrlsBatchWithClient(supabase, allFilePaths, undefined)
         : [];
     const urlMap = new Map();
     allFilePaths.forEach((path, index) => {
@@ -461,7 +461,7 @@ export async function get_event_and_tags_by_event_id(event_id) {
     // Generate signed URL for event
     let eventWithSignedUrl = transformedData;
     if (isNonEmptyStorageFilePath(transformedData.file_path)) {
-        const signedUrl = await generateSignedUrl(transformedData.file_path, undefined, supabase);
+        const signedUrl = await generateSignedUrlWithClient(supabase, transformedData.file_path, undefined);
         eventWithSignedUrl = {
             ...transformedData,
             media_url: signedUrl,

package/dist/helpers/users.d.ts

@@ -1,13 +1,12 @@
 import { IUser, IUserAndRole, IUserProfileRow, IUserRolePerHerd } from "../types/db";
-import { IWebResponseCompatible } from "../types/requests";
-import { SupabaseClient } from "@supabase/supabase-js";
 import { Database } from "../types/supabase";
+import { IWebResponseCompatible } from "../types/requests";
+export type UserProfileUpdate = Database["public"]["Tables"]["users"]["Update"];
 export declare function server_get_user_roles(herd_id: number): Promise<IWebResponseCompatible<IUserRolePerHerd[]>>;
 export declare function server_get_user(): Promise<IWebResponseCompatible<IUser | null>>;
-export declare function server_get_users_with_herd_access(herd_id: number, supabaseClient?: SupabaseClient): Promise<IWebResponseCompatible<IUserAndRole[]>>;
-export declare function server_get_users_with_herd_access_batch(herd_ids: number[], client: SupabaseClient): Promise<IWebResponseCompatible<Record<number, IUserAndRole[]>>>;
+export declare function server_get_users_with_herd_access(herd_id: number): Promise<IWebResponseCompatible<IUserAndRole[]>>;
+export declare function server_get_users_with_herd_access_batch(herd_ids: number[]): Promise<IWebResponseCompatible<Record<number, IUserAndRole[]>>>;
 export declare function server_upsert_user_herd_role(herd_id: number, username: string, herd_role_id: number): Promise<IWebResponseCompatible<IUserAndRole | null>>;
-export type UserProfileUpdate = Database["public"]["Tables"]["users"]["Update"];
-export declare function update_user_profile(client: SupabaseClient<Database>, user_id: string, patch: UserProfileUpdate): Promise<IWebResponseCompatible<IUserProfileRow | null>>;
-export declare function leave_herd_for_current_user(herd_id: number, supabaseClient?: SupabaseClient<Database>): Promise<IWebResponseCompatible<IUserRolePerHerd | null>>;
-export declare function remove_user_from_herd_for_admin(herd_id: number, user_id: string, supabaseClient?: SupabaseClient<Database>): Promise<IWebResponseCompatible<IUserRolePerHerd | null>>;
+export declare function update_user_profile(user_id: string, patch: UserProfileUpdate): Promise<IWebResponseCompatible<IUserProfileRow | null>>;
+export declare function leave_herd_for_current_user(herd_id: number): Promise<IWebResponseCompatible<IUserRolePerHerd | null>>;
+export declare function remove_user_from_herd_for_admin(herd_id: number, user_id: string): Promise<IWebResponseCompatible<IUserRolePerHerd | null>>;

package/dist/helpers/users.js

@@ -1,6 +1,7 @@
 "use server";
 import { newServerClient } from "../supabase/server";
 import { IWebResponse, EnumWebResponse, } from "../types/requests";
+import { get_users_with_herd_access_batch_query, } from "./users.queries";
 export async function server_get_user_roles(herd_id) {
     const supabase = await newServerClient();
     // fetch user role for herd
@@ -25,8 +26,8 @@ export async function server_get_user() {
     const new_user = data.user;
     return IWebResponse.success(new_user).to_compatible();
 }
-export async function server_get_users_with_herd_access(herd_id, supabaseClient) {
-    const supabase = supabaseClient || (await newServerClient());
+export async function server_get_users_with_herd_access(herd_id) {
+    const supabase = await newServerClient();
     const { data, error } = await supabase
         .from("users_roles_per_herd")
         .select(`
@@ -36,11 +37,7 @@ export async function server_get_users_with_herd_access(herd_id, supabaseClient)
     `)
         .eq("herd_id", herd_id);
     if (error) {
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: null,
-        };
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
     }
     const transformedData = (data ?? []).map((item) => ({
         user: item.users,
@@ -50,34 +47,8 @@ export async function server_get_users_with_herd_access(herd_id, supabaseClient)
     return IWebResponse.success(transformedData).to_compatible();
 }
 // Fetches users-with-role for many herds in one query, grouped by herd_id.
-export async function server_get_users_with_herd_access_batch(herd_ids, client) {
-    var _a;
-    if (herd_ids.length === 0) {
-        return IWebResponse.success({}).to_compatible();
-    }
-    const { data, error } = await client
-        .from("users_roles_per_herd")
-        .select(`
-      herd_id,
-      herd_role_id,
-      herd_roles (*),
-      users!users_roles_per_herd_user_id_fkey (*)
-    `)
-        .in("herd_id", herd_ids)
-        .order("herd_id", { ascending: true })
-        .order("user_id", { ascending: true });
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
-    }
-    const grouped = {};
-    for (const item of (data ?? [])) {
-        (grouped[_a = item.herd_id] ?? (grouped[_a] = [])).push({
-            user: item.users,
-            herd_role_id: item.herd_role_id,
-            herd_role: item.herd_roles,
-        });
-    }
-    return IWebResponse.success(grouped).to_compatible();
+export async function server_get_users_with_herd_access_batch(herd_ids) {
+    return get_users_with_herd_access_batch_query(await newServerClient(), herd_ids);
 }
 export async function server_upsert_user_herd_role(herd_id, username, herd_role_id) {
     const supabase = await newServerClient();
@@ -115,8 +86,9 @@ export async function server_upsert_user_herd_role(herd_id, username, herd_role_
         herd_role: herdRole,
     }).to_compatible();
 }
-export async function update_user_profile(client, user_id, patch) {
-    const { data, error } = await client
+export async function update_user_profile(user_id, patch) {
+    const supabase = await newServerClient();
+    const { data, error } = await supabase
         .from("users")
         .update(patch)
         .eq("id", user_id)
@@ -130,8 +102,8 @@ export async function update_user_profile(client, user_id, patch) {
     }
     return IWebResponse.success(data).to_compatible();
 }
-export async function leave_herd_for_current_user(herd_id, supabaseClient) {
-    const supabase = supabaseClient ?? (await newServerClient());
+export async function leave_herd_for_current_user(herd_id) {
+    const supabase = await newServerClient();
     const { data, error } = await supabase.rpc("leave_herd_for_current_user", {
         p_herd_id: herd_id,
     });
@@ -140,8 +112,8 @@ export async function leave_herd_for_current_user(herd_id, supabaseClient) {
     }
     return IWebResponse.success(data).to_compatible();
 }
-export async function remove_user_from_herd_for_admin(herd_id, user_id, supabaseClient) {
-    const supabase = supabaseClient ?? (await newServerClient());
+export async function remove_user_from_herd_for_admin(herd_id, user_id) {
+    const supabase = await newServerClient();
     const { data, error } = await supabase.rpc("remove_user_from_herd_for_admin", {
         p_herd_id: herd_id,
         p_user_id: user_id,

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

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

package/dist/helpers/users.queries.js

@@ -0,0 +1,30 @@
+import { EnumWebResponse, IWebResponse, } from "../types/requests";
+export async function get_users_with_herd_access_batch_query(client, herd_ids) {
+    var _a;
+    if (herd_ids.length === 0) {
+        return IWebResponse.success({}).to_compatible();
+    }
+    const { data, error } = await client
+        .from("users_roles_per_herd")
+        .select(`
+      herd_id,
+      herd_role_id,
+      herd_roles (*),
+      users!users_roles_per_herd_user_id_fkey (*)
+    `)
+        .in("herd_id", herd_ids)
+        .order("herd_id", { ascending: true })
+        .order("user_id", { ascending: true });
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    const grouped = {};
+    for (const item of data ?? []) {
+        (grouped[_a = item.herd_id] ?? (grouped[_a] = [])).push({
+            user: item.users,
+            herd_role_id: item.herd_role_id,
+            herd_role: item.herd_roles,
+        });
+    }
+    return IWebResponse.success(grouped).to_compatible();
+}

package/dist/helpers/versions_software_internal.d.ts

@@ -0,0 +1,6 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { IVersionsSoftwareWithBuildUrl } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+import { Database } from "../types/supabase";
+export declare function get_versions_software(client: SupabaseClient<Database>): Promise<IWebResponseCompatible<IVersionsSoftwareWithBuildUrl[]>>;
+export declare function get_versions_software_by_system(client: SupabaseClient<Database>, system: string): Promise<IWebResponseCompatible<IVersionsSoftwareWithBuildUrl[]>>;

package/dist/helpers/versions_software_internal.js

@@ -0,0 +1,53 @@
+import { IWebResponse } from "../types/requests";
+import { generateSignedUrlsBatchWithClient } from "./storage_internal";
+async function attachBuildArtifactUrls(client, data) {
+    const uniquePaths = Array.from(new Set(data
+        .map((version) => version.path_build_artifact)
+        .filter((path) => !!path)));
+    if (uniquePaths.length === 0) {
+        return data.map((version) => ({
+            ...version,
+            build_artifact_url: null,
+        }));
+    }
+    const signedUrls = await generateSignedUrlsBatchWithClient(client, uniquePaths);
+    const urlMap = new Map();
+    uniquePaths.forEach((path, index) => {
+        urlMap.set(path, signedUrls[index]);
+    });
+    return data.map((version) => ({
+        ...version,
+        build_artifact_url: version.path_build_artifact
+            ? urlMap.get(version.path_build_artifact) ?? null
+            : null,
+    }));
+}
+export async function get_versions_software(client) {
+    const { data, error } = await client
+        .from("versions_software")
+        .select("*")
+        .order("created_at", { ascending: false });
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error("No software versions found").to_compatible();
+    }
+    const withUrls = await attachBuildArtifactUrls(client, data);
+    return IWebResponse.success(withUrls).to_compatible();
+}
+export async function get_versions_software_by_system(client, system) {
+    const { data, error } = await client
+        .from("versions_software")
+        .select("*")
+        .eq("system", system)
+        .order("created_at", { ascending: false });
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error(`No software versions found for system: ${system}`).to_compatible();
+    }
+    const withUrls = await attachBuildArtifactUrls(client, data);
+    return IWebResponse.success(withUrls).to_compatible();
+}

package/dist/helpers/versions_software_server.d.ts

@@ -1,5 +1,4 @@
 import { IVersionsSoftwareWithBuildUrl } from "../types/db";
 import { IWebResponseCompatible } from "../types/requests";
-import { SupabaseClient } from "@supabase/supabase-js";
-export declare function server_get_versions_software(client?: SupabaseClient): Promise<IWebResponseCompatible<IVersionsSoftwareWithBuildUrl[]>>;
-export declare function server_get_versions_software_by_system(system: string, client?: SupabaseClient): Promise<IWebResponseCompatible<IVersionsSoftwareWithBuildUrl[]>>;
+export declare function server_get_versions_software(): Promise<IWebResponseCompatible<IVersionsSoftwareWithBuildUrl[]>>;
+export declare function server_get_versions_software_by_system(system: string): Promise<IWebResponseCompatible<IVersionsSoftwareWithBuildUrl[]>>;

package/dist/helpers/versions_software_server.js

@@ -1,30 +1,32 @@
 "use server";
 import { newServerClient } from "../supabase/server";
 import { IWebResponse } from "../types/requests";
-import { generateSignedUrlsBatch } from "./storage";
-/** Resolves path_build_artifact to signed URLs. Paths must be full storage paths (e.g. software_build_artifacts/...). */
-async function attachBuildArtifactUrls(data, client) {
+import { generateSignedUrlsBatchWithClient } from "./storage_internal";
+async function attachBuildArtifactUrls(client, data) {
     const uniquePaths = Array.from(new Set(data
-        .map((v) => v.path_build_artifact)
+        .map((version) => version.path_build_artifact)
         .filter((path) => !!path)));
     if (uniquePaths.length === 0) {
-        return data.map((v) => ({ ...v, build_artifact_url: null }));
+        return data.map((version) => ({
+            ...version,
+            build_artifact_url: null,
+        }));
     }
-    const signedUrls = await generateSignedUrlsBatch(uniquePaths, undefined, client);
+    const signedUrls = await generateSignedUrlsBatchWithClient(client, uniquePaths);
     const urlMap = new Map();
     uniquePaths.forEach((path, index) => {
         urlMap.set(path, signedUrls[index]);
     });
-    return data.map((v) => ({
-        ...v,
-        build_artifact_url: v.path_build_artifact
-            ? urlMap.get(v.path_build_artifact) ?? null
+    return data.map((version) => ({
+        ...version,
+        build_artifact_url: version.path_build_artifact
+            ? urlMap.get(version.path_build_artifact) ?? null
             : null,
     }));
 }
-export async function server_get_versions_software(client) {
-    const supabase = client || (await newServerClient());
-    const { data, error } = await supabase
+export async function server_get_versions_software() {
+    const client = await newServerClient();
+    const { data, error } = await client
         .from("versions_software")
         .select("*")
         .order("created_at", { ascending: false });
@@ -34,12 +36,12 @@ export async function server_get_versions_software(client) {
     if (!data) {
         return IWebResponse.error("No software versions found").to_compatible();
     }
-    const withUrls = await attachBuildArtifactUrls(data, client);
+    const withUrls = await attachBuildArtifactUrls(client, data);
     return IWebResponse.success(withUrls).to_compatible();
 }
-export async function server_get_versions_software_by_system(system, client) {
-    const supabase = client || (await newServerClient());
-    const { data, error } = await supabase
+export async function server_get_versions_software_by_system(system) {
+    const client = await newServerClient();
+    const { data, error } = await client
         .from("versions_software")
         .select("*")
         .eq("system", system)
@@ -50,6 +52,6 @@ export async function server_get_versions_software_by_system(system, client) {
     if (!data) {
         return IWebResponse.error(`No software versions found for system: ${system}`).to_compatible();
     }
-    const withUrls = await attachBuildArtifactUrls(data, client);
+    const withUrls = await attachBuildArtifactUrls(client, data);
     return IWebResponse.success(withUrls).to_compatible();
 }