@adventurelabs/scout-core 1.5.4 → 2.0.0

package/dist/helpers/{artifacts.internal.js → artifacts.queries.js}

@@ -1,26 +1,6 @@
 import { IWebResponse } from "../types/requests";
-import { generateSignedUrlsBatchWithClient, generateSignedUrlWithClient, } from "./storage_internal";
-import { isNonEmptyStorageFilePath } from "./storagePath";
-async function addArtifactMediaUrls(data, client) {
-    const uniqueFilePaths = Array.from(new Set(data
-        .map((artifact) => artifact.file_path)
-        .filter(isNonEmptyStorageFilePath)));
-    if (uniqueFilePaths.length === 0) {
-        return data;
-    }
-    const signedUrls = await generateSignedUrlsBatchWithClient(client, uniqueFilePaths);
-    const urlMap = new Map();
-    uniqueFilePaths.forEach((path, index) => {
-        urlMap.set(path, signedUrls[index]);
-    });
-    return data.map((artifact) => ({
-        ...artifact,
-        media_url: isNonEmptyStorageFilePath(artifact.file_path)
-            ? urlMap.get(artifact.file_path) ?? null
-            : null,
-    }));
-}
-export async function getArtifactByIdWithClient(client, id) {
+import { addArtifactMediaUrls } from "./media_urls";
+export async function get_artifact_by_id_query(client, id) {
     const { data, error } = await client
         .from("artifacts")
         .select("*")
@@ -33,16 +13,10 @@ export async function getArtifactByIdWithClient(client, id) {
         return IWebResponse.success(null).to_compatible();
     }
     const artifact = data;
-    let media_url = null;
-    if (isNonEmptyStorageFilePath(artifact.file_path)) {
-        media_url = await generateSignedUrlWithClient(client, artifact.file_path);
-    }
-    return IWebResponse.success({
-        ...artifact,
-        media_url,
-    }).to_compatible();
+    const [artifactWithUrls] = await addArtifactMediaUrls(client, [artifact]);
+    return IWebResponse.success(artifactWithUrls).to_compatible();
 }
-export async function getArtifactsByHerdWithClient(client, herd_id, limit, offset, options) {
+export async function get_artifacts_by_herd_query(client, herd_id, limit = 50, offset = 0, options) {
     const { data, error } = await client.rpc("get_artifacts_for_herd", {
         herd_id_caller: herd_id,
         limit_caller: limit,
@@ -56,10 +30,10 @@ export async function getArtifactsByHerdWithClient(client, herd_id, limit, offse
     if (!data) {
         return IWebResponse.error("No artifacts found for herd").to_compatible();
     }
-    const artifactsWithUrls = await addArtifactMediaUrls(data, client);
+    const artifactsWithUrls = await addArtifactMediaUrls(client, data);
     return IWebResponse.success(artifactsWithUrls).to_compatible();
 }
-export async function getArtifactsByDeviceIdWithClient(client, device_id, limit, offset) {
+export async function get_artifacts_by_device_id_query(client, device_id, limit = 50, offset = 0) {
     const { data, error } = await client.rpc("get_artifacts_for_device", {
         device_id_caller: device_id,
         limit_caller: limit,
@@ -71,10 +45,19 @@ export async function getArtifactsByDeviceIdWithClient(client, device_id, limit,
     if (!data) {
         return IWebResponse.error("No artifacts found for device").to_compatible();
     }
-    const artifactsWithUrls = await addArtifactMediaUrls(data, client);
+    const artifactsWithUrls = await addArtifactMediaUrls(client, data);
     return IWebResponse.success(artifactsWithUrls).to_compatible();
 }
-export async function getArtifactsByDeviceIdsBatchWithClient(client, device_ids, limit_per_device, options) {
+export async function get_total_artifacts_by_herd_query(client, herd_id) {
+    const { data, error } = await client.rpc("get_total_artifacts_for_herd", {
+        herd_id_caller: herd_id,
+    });
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    return IWebResponse.success(data || 0).to_compatible();
+}
+export async function get_artifacts_by_device_ids_batch_query(client, device_ids, limit_per_device = 10, options) {
     if (device_ids.length === 0) {
         return {};
     }
@@ -88,7 +71,7 @@ export async function getArtifactsByDeviceIdsBatchWithClient(client, device_ids,
         console.warn("Error fetching artifacts batch:", error?.message);
         return {};
     }
-    const artifactsWithUrls = await addArtifactMediaUrls(data, client);
+    const artifactsWithUrls = await addArtifactMediaUrls(client, data);
     const artifactsByDevice = {};
     artifactsWithUrls.forEach((artifact) => {
         if (!artifactsByDevice[artifact.device_id]) {
@@ -98,7 +81,7 @@ export async function getArtifactsByDeviceIdsBatchWithClient(client, device_ids,
     });
     return artifactsByDevice;
 }
-export async function insertArtifactWithClient(client, artifact) {
+export async function insert_artifact_query(client, artifact) {
     const arr = Array.isArray(artifact) ? artifact : [artifact];
     const { data, error } = await client
         .from("artifacts")
@@ -109,7 +92,7 @@ export async function insertArtifactWithClient(client, artifact) {
     }
     return IWebResponse.success(data || []).to_compatible();
 }
-export async function updateArtifactWithClient(client, artifact) {
+export async function update_artifact_query(client, artifact) {
     const arr = Array.isArray(artifact) ? artifact : [artifact];
     const results = [];
     for (const record of arr) {
@@ -129,7 +112,7 @@ export async function updateArtifactWithClient(client, artifact) {
     }
     return IWebResponse.success(results).to_compatible();
 }
-export async function deleteArtifactWithClient(client, id) {
+export async function delete_artifact_query(client, id) {
     const ids = Array.isArray(id) ? id : [id];
     const { error } = await client.from("artifacts").delete().in("id", ids);
     if (error) {
@@ -137,12 +120,12 @@ export async function deleteArtifactWithClient(client, id) {
     }
     return IWebResponse.success(true).to_compatible();
 }
-export async function matchArtifactsByVertexEmbeddingWithClient(client, query_embedding, match_threshold, match_count, herd_id) {
+export async function match_artifacts_by_vertex_embedding_query(client, query_embedding, match_threshold, match_count, options) {
     const { data, error } = await client.rpc("match_artifacts_by_vertex_embedding", {
         query_embedding,
         match_threshold,
         match_count,
-        herd_id_caller: herd_id ?? null,
+        herd_id_caller: options?.herd_id ?? null,
     });
     if (error) {
         return IWebResponse.error(error.message).to_compatible();

package/dist/helpers/auth.d.ts

@@ -1,7 +1,7 @@
 import { SupabaseClient } from "@supabase/supabase-js";
 import { Database } from "../types/supabase";
 import { IWebResponseCompatible } from "../types/requests";
-/** Deprecated */
+/** @deprecated Use is_scout_email_valid. */
 export declare function isEmailValidForLogin(email: string, approved_domains?: string[]): boolean;
 export declare function isCurrentUserPlatformSuperadmin(client: SupabaseClient<Database>): Promise<boolean>;
 export declare function is_scout_email_valid(client: SupabaseClient<Database>, email: string): Promise<IWebResponseCompatible<boolean>>;

package/dist/helpers/auth.js

@@ -1,13 +1,12 @@
 import { validateEmail } from "./email";
 import { IWebResponse } from "../types/requests";
 const APPROVED_DOMAINS = ["adventurelabs.earth", "conservaition.ai"];
-/** Deprecated */
+/** @deprecated Use is_scout_email_valid. */
 export function isEmailValidForLogin(email, approved_domains = APPROVED_DOMAINS) {
     return (validateEmail(email) && isEmailFromApprovedDomain(email, approved_domains));
 }
-/** Deprecated */
 function isEmailFromApprovedDomain(email, approved_domains = APPROVED_DOMAINS) {
-    return approved_domains.filter((domain) => email.endsWith(domain)).length > 0;
+    return approved_domains.some((domain) => email.endsWith(domain));
 }
 export async function isCurrentUserPlatformSuperadmin(client) {
     const { data, error } = await client.rpc("is_platform_superadmin_current_user");

package/dist/helpers/auth_server.d.ts

@@ -0,0 +1,2 @@
+export declare function server_isCurrentUserPlatformSuperadmin(): Promise<boolean>;
+export declare function server_is_scout_email_valid(email: string): Promise<import("../types").IWebResponseCompatible<boolean>>;

package/dist/helpers/auth_server.js

@@ -0,0 +1,10 @@
+import { newServerClient } from "../supabase/server";
+import { is_scout_email_valid, isCurrentUserPlatformSuperadmin, } from "./auth";
+export async function server_isCurrentUserPlatformSuperadmin() {
+    const client = await newServerClient();
+    return isCurrentUserPlatformSuperadmin(client);
+}
+export async function server_is_scout_email_valid(email) {
+    const client = await newServerClient();
+    return is_scout_email_valid(client, email);
+}

package/dist/helpers/certificates_server.d.ts

@@ -0,0 +1,101 @@
+import { CertificateInsert, CertificateUpdate } from "../types/db";
+export declare function server_get_certificates_by_device(device_id: number): Promise<import("../types").IWebResponseCompatible<{
+    created_at: string;
+    expiration: string | null;
+    id: number;
+    issuer: string;
+    part_id: number | null;
+    tracking_number: string | null;
+    type: string;
+    updated_at: string | null;
+}[]>>;
+export declare function server_get_certificate_by_device(certificate_id: number, device_id: number): Promise<import("../types").IWebResponseCompatible<{
+    created_at: string;
+    expiration: string | null;
+    id: number;
+    issuer: string;
+    part_id: number | null;
+    tracking_number: string | null;
+    type: string;
+    updated_at: string | null;
+} | null>>;
+export declare function server_create_certificate_by_device(device_id: number, row: CertificateInsert): Promise<import("../types").IWebResponseCompatible<{
+    created_at: string;
+    expiration: string | null;
+    id: number;
+    issuer: string;
+    part_id: number | null;
+    tracking_number: string | null;
+    type: string;
+    updated_at: string | null;
+} | null>>;
+export declare function server_update_certificate_by_device(certificate_id: number, device_id: number, patch: CertificateUpdate): Promise<import("../types").IWebResponseCompatible<{
+    created_at: string;
+    expiration: string | null;
+    id: number;
+    issuer: string;
+    part_id: number | null;
+    tracking_number: string | null;
+    type: string;
+    updated_at: string | null;
+} | null>>;
+export declare function server_delete_certificate_by_device(certificate_id: number, device_id: number): Promise<import("../types").IWebResponseCompatible<{
+    created_at: string;
+    expiration: string | null;
+    id: number;
+    issuer: string;
+    part_id: number | null;
+    tracking_number: string | null;
+    type: string;
+    updated_at: string | null;
+} | null>>;
+export declare function server_get_certificates_by_part(part_id: number): Promise<import("../types").IWebResponseCompatible<{
+    created_at: string;
+    expiration: string | null;
+    id: number;
+    issuer: string;
+    part_id: number | null;
+    tracking_number: string | null;
+    type: string;
+    updated_at: string | null;
+}[]>>;
+export declare function server_get_certificate_by_part(certificate_id: number, part_id: number): Promise<import("../types").IWebResponseCompatible<{
+    created_at: string;
+    expiration: string | null;
+    id: number;
+    issuer: string;
+    part_id: number | null;
+    tracking_number: string | null;
+    type: string;
+    updated_at: string | null;
+} | null>>;
+export declare function server_create_certificate_by_part(part_id: number, row: CertificateInsert): Promise<import("../types").IWebResponseCompatible<{
+    created_at: string;
+    expiration: string | null;
+    id: number;
+    issuer: string;
+    part_id: number | null;
+    tracking_number: string | null;
+    type: string;
+    updated_at: string | null;
+} | null>>;
+export declare function server_update_certificate_by_part(certificate_id: number, part_id: number, patch: CertificateUpdate): Promise<import("../types").IWebResponseCompatible<{
+    created_at: string;
+    expiration: string | null;
+    id: number;
+    issuer: string;
+    part_id: number | null;
+    tracking_number: string | null;
+    type: string;
+    updated_at: string | null;
+} | null>>;
+export declare function server_delete_certificate_by_part(certificate_id: number, part_id: number): Promise<import("../types").IWebResponseCompatible<{
+    created_at: string;
+    expiration: string | null;
+    id: number;
+    issuer: string;
+    part_id: number | null;
+    tracking_number: string | null;
+    type: string;
+    updated_at: string | null;
+} | null>>;

package/dist/helpers/certificates_server.js

@@ -0,0 +1,42 @@
+import { newServerClient } from "../supabase/server";
+import { create_certificate_by_device, create_certificate_by_part, delete_certificate_by_device, delete_certificate_by_part, get_certificate_by_device, get_certificate_by_part, get_certificates_by_device, get_certificates_by_part, update_certificate_by_device, update_certificate_by_part, } from "./certificates";
+export async function server_get_certificates_by_device(device_id) {
+    const client = await newServerClient();
+    return get_certificates_by_device(client, device_id);
+}
+export async function server_get_certificate_by_device(certificate_id, device_id) {
+    const client = await newServerClient();
+    return get_certificate_by_device(client, certificate_id, device_id);
+}
+export async function server_create_certificate_by_device(device_id, row) {
+    const client = await newServerClient();
+    return create_certificate_by_device(client, device_id, row);
+}
+export async function server_update_certificate_by_device(certificate_id, device_id, patch) {
+    const client = await newServerClient();
+    return update_certificate_by_device(client, certificate_id, device_id, patch);
+}
+export async function server_delete_certificate_by_device(certificate_id, device_id) {
+    const client = await newServerClient();
+    return delete_certificate_by_device(client, certificate_id, device_id);
+}
+export async function server_get_certificates_by_part(part_id) {
+    const client = await newServerClient();
+    return get_certificates_by_part(client, part_id);
+}
+export async function server_get_certificate_by_part(certificate_id, part_id) {
+    const client = await newServerClient();
+    return get_certificate_by_part(client, certificate_id, part_id);
+}
+export async function server_create_certificate_by_part(part_id, row) {
+    const client = await newServerClient();
+    return create_certificate_by_part(client, part_id, row);
+}
+export async function server_update_certificate_by_part(certificate_id, part_id, patch) {
+    const client = await newServerClient();
+    return update_certificate_by_part(client, certificate_id, part_id, patch);
+}
+export async function server_delete_certificate_by_part(certificate_id, part_id) {
+    const client = await newServerClient();
+    return delete_certificate_by_part(client, certificate_id, part_id);
+}

package/dist/helpers/chat.d.ts

@@ -1,6 +1,5 @@
 import { IWebResponseCompatible } from "../types/requests";
-import { TablesInsert } from "../types/supabase";
-export type ChatMessageInsert = TablesInsert<"chat">;
+export type { ChatMessageInsert } from "./chat.queries";
 export declare function server_insert_chat_message(message: string, herd_id: number, sender?: string): Promise<IWebResponseCompatible<{
     id: number;
 }>>;

package/dist/helpers/chat.js

@@ -1,43 +1,8 @@
-"use server";
 import { newServerClient } from "../supabase/server";
-import { IWebResponse, EnumWebResponse } from "../types/requests";
+import { get_chat_messages_query, insert_chat_message_query, } from "./chat.queries";
 export async function server_insert_chat_message(message, herd_id, sender) {
-    const supabase = await newServerClient();
-    const chatMessage = {
-        message,
-        herd_id,
-        sender: sender || null,
-    };
-    const { data, error } = await supabase
-        .from("chat")
-        .insert(chatMessage)
-        .select("id")
-        .single();
-    if (error) {
-        console.warn("Error inserting chat message:", error.message);
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: `Failed to insert chat message: ${error.message}`,
-            data: null,
-        };
-    }
-    return IWebResponse.success({ id: data.id }).to_compatible();
+    return insert_chat_message_query(await newServerClient(), message, herd_id, sender);
 }
 export async function server_get_chat_messages(limit = 50, offset = 0, herd_id) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("chat")
-        .select("id, message, sender, created_at")
-        .order("created_at", { ascending: false })
-        .range(offset, offset + limit - 1)
-        .eq("herd_id", herd_id);
-    if (error) {
-        console.warn("Error fetching chat messages:", error.message);
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: `Failed to fetch chat messages: ${error.message}`,
-            data: [],
-        };
-    }
-    return IWebResponse.success(data || []).to_compatible();
+    return get_chat_messages_query(await newServerClient(), limit, offset, herd_id);
 }

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

@@ -0,0 +1,13 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { IWebResponseCompatible } from "../types/requests";
+import { Database, TablesInsert } from "../types/supabase";
+export type ChatMessageInsert = TablesInsert<"chat">;
+export declare function insert_chat_message_query(client: SupabaseClient<Database>, message: string, herd_id: number, sender?: string): Promise<IWebResponseCompatible<{
+    id: number;
+}>>;
+export declare function get_chat_messages_query(client: SupabaseClient<Database>, limit: number | undefined, offset: number | undefined, herd_id: number): Promise<IWebResponseCompatible<Array<{
+    id: number;
+    message: string;
+    sender: string | null;
+    created_at: string;
+}>>>;

package/dist/helpers/chat.queries.js

@@ -0,0 +1,39 @@
+import { EnumWebResponse, IWebResponse, } from "../types/requests";
+export async function insert_chat_message_query(client, message, herd_id, sender) {
+    const chatMessage = {
+        message,
+        herd_id,
+        sender: sender || null,
+    };
+    const { data, error } = await client
+        .from("chat")
+        .insert(chatMessage)
+        .select("id")
+        .single();
+    if (error) {
+        console.warn("Error inserting chat message:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: `Failed to insert chat message: ${error.message}`,
+            data: null,
+        };
+    }
+    return IWebResponse.success({ id: data.id }).to_compatible();
+}
+export async function get_chat_messages_query(client, limit = 50, offset = 0, herd_id) {
+    const { data, error } = await client
+        .from("chat")
+        .select("id, message, sender, created_at")
+        .order("created_at", { ascending: false })
+        .range(offset, offset + limit - 1)
+        .eq("herd_id", herd_id);
+    if (error) {
+        console.warn("Error fetching chat messages:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: `Failed to fetch chat messages: ${error.message}`,
+            data: [],
+        };
+    }
+    return IWebResponse.success(data || []).to_compatible();
+}

package/dist/helpers/client_abilities_jwt_keys.js

@@ -1,4 +1,3 @@
-"use server";
 import { newServerClient } from "../supabase/server";
 import { IWebResponse } from "../types/requests";
 /** Register or rotate a verification key (service_role or platform superadmin). */

package/dist/helpers/client_abilities_token_server.d.ts

@@ -1,3 +1,4 @@
 import { IClientAbilitiesTokenMint } from "../types/client_abilities_token";
 import { IWebResponseCompatible } from "../types/requests";
 export declare function server_mint_client_abilities_token(): Promise<IWebResponseCompatible<IClientAbilitiesTokenMint>>;
+export declare function server_get_client_abilities_jwt_public_keys(): Promise<IWebResponseCompatible<import("../types").IClientAbilitiesJwtPublicKeyEntry[]>>;

package/dist/helpers/client_abilities_token_server.js

@@ -1,7 +1,10 @@
-"use server";
 import { newServerClient } from "../supabase/server";
-import { mint_client_abilities_token } from "./client_abilities_token";
+import { get_client_abilities_jwt_public_keys, mint_client_abilities_token, } from "./client_abilities_token";
 export async function server_mint_client_abilities_token() {
     const client = await newServerClient();
     return mint_client_abilities_token(client);
 }
+export async function server_get_client_abilities_jwt_public_keys() {
+    const client = await newServerClient();
+    return get_client_abilities_jwt_public_keys(client);
+}

package/dist/helpers/connectivity.d.ts

@@ -1,5 +1,6 @@
 import { IWebResponseCompatible } from "../types/requests";
 import { IConnectivityWithCoordinates, IConnectivity, ConnectivityInsert, ConnectivityUpdate } from "../types/db";
+import { type HerdConnectivityTimeRangeResponse } from "./connectivity.queries";
 export declare function server_get_connectivity_by_session_id(sessionId: number): Promise<IWebResponseCompatible<IConnectivityWithCoordinates[]>>;
 export declare function server_get_connectivity_by_device_id(deviceId: number, timestamp: string): Promise<IWebResponseCompatible<IConnectivityWithCoordinates[]>>;
 export declare function server_insert_connectivity(connectivity: ConnectivityInsert | ConnectivityInsert[]): Promise<IWebResponseCompatible<IConnectivity[]>>;
@@ -8,11 +9,6 @@ export declare function server_update_connectivity(connectivity: (ConnectivityUp
 }) | (ConnectivityUpdate & {
     id: number;
 })[]): Promise<IWebResponseCompatible<IConnectivity[]>>;
-/** Pagination info returned with herd time range connectivity. */
-export type HerdConnectivityTimeRangeResponse = IWebResponseCompatible<IConnectivityWithCoordinates[]> & {
-    hasMore: boolean;
-    nextOffset: number;
-};
 /** Connectivity records for a herd within a time range. Returns most recent rows with hasMore and nextOffset for pagination. */
 export declare function server_get_connectivity_for_herd_time_range(herdId: number, startTimestamp: string, endTimestamp: string, maxCount?: number, offset?: number): Promise<HerdConnectivityTimeRangeResponse>;
 /** Connectivity records for an artifact (uses session when set, else device + time window). */

package/dist/helpers/connectivity.js

@@ -1,155 +1,22 @@
-"use server";
 import { newServerClient } from "../supabase/server";
-import { EnumWebResponse, IWebResponse, } from "../types/requests";
-// Get connectivity by session id using RPC function with coordinates
+import { get_connectivity_by_device_id_query, get_connectivity_by_session_id_query, get_connectivity_for_artifact_query, get_connectivity_for_herd_time_range_query, insert_connectivity_query, update_connectivity_query, } from "./connectivity.queries";
 export async function server_get_connectivity_by_session_id(sessionId) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase.rpc("get_connectivity_with_coordinates", { session_id_caller: sessionId });
-    if (error) {
-        console.warn("Error fetching connectivity by session id:", error.message);
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: [],
-        };
-    }
-    // Sort by timestamp_start in ascending order
-    const sortedConnectivity = (data || []).sort((a, b) => {
-        if (!a.timestamp_start || !b.timestamp_start)
-            return 0;
-        return (new Date(a.timestamp_start).getTime() -
-            new Date(b.timestamp_start).getTime());
-    });
-    return IWebResponse.success(sortedConnectivity).to_compatible();
+    return get_connectivity_by_session_id_query(await newServerClient(), sessionId);
 }
-// Get all connectivity items after a specific timestamp, filtered by device ID
-// Timestamp should be formatted as YYYY-MM-DDTHH:mm:ss.SSSZ
 export async function server_get_connectivity_by_device_id(deviceId, timestamp) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase.rpc("get_connectivity_with_coordinates_by_device_and_timestamp", { device_id_caller: deviceId, timestamp_filter: timestamp });
-    if (error) {
-        console.warn("Error fetching connectivity by session id:", error.message);
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: [],
-        };
-    }
-    // Sort by timestamp_start in ascending order
-    const sortedConnectivity = (data || []).sort((a, b) => {
-        if (!a.timestamp_start || !b.timestamp_start)
-            return 0;
-        return (new Date(a.timestamp_start).getTime() -
-            new Date(b.timestamp_start).getTime());
-    });
-    return IWebResponse.success(sortedConnectivity).to_compatible();
+    return get_connectivity_by_device_id_query(await newServerClient(), deviceId, timestamp);
 }
-// Insert new connectivity records (accepts array for batch operations)
 export async function server_insert_connectivity(connectivity) {
-    const client = await newServerClient();
-    const connectivityArray = Array.isArray(connectivity)
-        ? connectivity
-        : [connectivity];
-    const { data, error } = await client
-        .from("connectivity")
-        .insert(connectivityArray)
-        .select("*");
-    if (error) {
-        console.warn("Error inserting connectivity:", error.message);
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: [],
-        };
-    }
-    return IWebResponse.success(data || []).to_compatible();
+    return insert_connectivity_query(await newServerClient(), connectivity);
 }
-// Update existing connectivity records (accepts array for batch operations)
-// Each connectivity record in the array must include an 'id' field
 export async function server_update_connectivity(connectivity) {
-    const client = await newServerClient();
-    const connectivityArray = Array.isArray(connectivity)
-        ? connectivity
-        : [connectivity];
-    const updatedConnectivity = [];
-    for (const record of connectivityArray) {
-        const { id, ...updateData } = record;
-        delete updateData.inserted_at;
-        const { data, error } = await client
-            .from("connectivity")
-            .update(updateData)
-            .eq("id", id)
-            .select("*")
-            .single();
-        if (error) {
-            console.warn("Error updating connectivity:", error.message);
-            return {
-                status: EnumWebResponse.ERROR,
-                msg: error.message,
-                data: [],
-            };
-        }
-        if (data) {
-            updatedConnectivity.push(data);
-        }
-    }
-    return IWebResponse.success(updatedConnectivity).to_compatible();
+    return update_connectivity_query(await newServerClient(), connectivity);
 }
 /** Connectivity records for a herd within a time range. Returns most recent rows with hasMore and nextOffset for pagination. */
 export async function server_get_connectivity_for_herd_time_range(herdId, startTimestamp, endTimestamp, maxCount = 1000, offset = 0) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase.rpc("get_connectivity_for_herd_time_range", {
-        herd_id_caller: herdId,
-        start_timestamp_caller: startTimestamp,
-        end_timestamp_caller: endTimestamp,
-        max_elements_caller: maxCount + 1,
-        offset_caller: offset,
-    });
-    if (error) {
-        console.warn("Error fetching connectivity for herd time range:", error.message);
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: [],
-            hasMore: false,
-            nextOffset: offset,
-        };
-    }
-    const sorted = (data || []).sort((a, b) => {
-        if (!a.timestamp_start || !b.timestamp_start)
-            return 0;
-        return (new Date(a.timestamp_start).getTime() -
-            new Date(b.timestamp_start).getTime());
-    });
-    const hasMore = sorted.length > maxCount;
-    const items = hasMore ? sorted.slice(0, maxCount) : sorted;
-    const nextOffset = offset + items.length;
-    return {
-        ...IWebResponse.success(items).to_compatible(),
-        hasMore,
-        nextOffset,
-    };
+    return get_connectivity_for_herd_time_range_query(await newServerClient(), herdId, startTimestamp, endTimestamp, maxCount, offset);
 }
 /** Connectivity records for an artifact (uses session when set, else device + time window). */
 export async function server_get_connectivity_for_artifact(artifactId, maxElements = 1000) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase.rpc("get_connectivity_for_artifact", {
-        artifact_id_caller: artifactId,
-        max_elements_caller: maxElements,
-    });
-    if (error) {
-        console.warn("Error fetching connectivity for artifact:", error.message);
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: [],
-        };
-    }
-    const sortedConnectivity = (data || []).sort((a, b) => {
-        if (!a.timestamp_start || !b.timestamp_start)
-            return 0;
-        return (new Date(a.timestamp_start).getTime() -
-            new Date(b.timestamp_start).getTime());
-    });
-    return IWebResponse.success(sortedConnectivity).to_compatible();
+    return get_connectivity_for_artifact_query(await newServerClient(), artifactId, maxElements);
 }

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

@@ -0,0 +1,18 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { ConnectivityInsert, ConnectivityUpdate, IConnectivity, IConnectivityWithCoordinates } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+import { Database } from "../types/supabase";
+export type HerdConnectivityTimeRangeResponse = IWebResponseCompatible<IConnectivityWithCoordinates[]> & {
+    hasMore: boolean;
+    nextOffset: number;
+};
+export declare function get_connectivity_by_session_id_query(client: SupabaseClient<Database>, sessionId: number): Promise<IWebResponseCompatible<IConnectivityWithCoordinates[]>>;
+export declare function get_connectivity_by_device_id_query(client: SupabaseClient<Database>, deviceId: number, timestamp: string): Promise<IWebResponseCompatible<IConnectivityWithCoordinates[]>>;
+export declare function insert_connectivity_query(client: SupabaseClient<Database>, connectivity: ConnectivityInsert | ConnectivityInsert[]): Promise<IWebResponseCompatible<IConnectivity[]>>;
+export declare function update_connectivity_query(client: SupabaseClient<Database>, connectivity: (ConnectivityUpdate & {
+    id: number;
+}) | (ConnectivityUpdate & {
+    id: number;
+})[]): Promise<IWebResponseCompatible<IConnectivity[]>>;
+export declare function get_connectivity_for_herd_time_range_query(client: SupabaseClient<Database>, herdId: number, startTimestamp: string, endTimestamp: string, maxCount?: number, offset?: number): Promise<HerdConnectivityTimeRangeResponse>;
+export declare function get_connectivity_for_artifact_query(client: SupabaseClient<Database>, artifactId: number, maxElements?: number): Promise<IWebResponseCompatible<IConnectivityWithCoordinates[]>>;