@adventurelabs/scout-core 1.5.4 → 2.0.0

package/dist/helpers/connectivity.queries.js

@@ -0,0 +1,121 @@
+import { EnumWebResponse, IWebResponse, } from "../types/requests";
+function sortConnectivityByTimestamp(data) {
+    return 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());
+    });
+}
+export async function get_connectivity_by_session_id_query(client, sessionId) {
+    const { data, error } = await client.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: [],
+        };
+    }
+    return IWebResponse.success(sortConnectivityByTimestamp(data || [])).to_compatible();
+}
+export async function get_connectivity_by_device_id_query(client, deviceId, timestamp) {
+    const { data, error } = await client.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: [],
+        };
+    }
+    return IWebResponse.success(sortConnectivityByTimestamp(data || [])).to_compatible();
+}
+export async function insert_connectivity_query(client, connectivity) {
+    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();
+}
+export async function update_connectivity_query(client, connectivity) {
+    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();
+}
+export async function get_connectivity_for_herd_time_range_query(client, herdId, startTimestamp, endTimestamp, maxCount = 1000, offset = 0) {
+    const { data, error } = await client.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 = sortConnectivityByTimestamp(data || []);
+    const hasMore = sorted.length > maxCount;
+    const items = hasMore ? sorted.slice(0, maxCount) : sorted;
+    return {
+        ...IWebResponse.success(items).to_compatible(),
+        hasMore,
+        nextOffset: offset + items.length,
+    };
+}
+export async function get_connectivity_for_artifact_query(client, artifactId, maxElements = 1000) {
+    const { data, error } = await client.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: [],
+        };
+    }
+    return IWebResponse.success(sortConnectivityByTimestamp(data || [])).to_compatible();
+}

package/dist/helpers/contacts_server.d.ts

@@ -0,0 +1,63 @@
+import { ContactInsert, ContactUpdate } from "../types/db";
+export declare function server_get_contacts_by_herd_id(herd_id: number, options?: {
+    include_inactive?: boolean;
+}): Promise<import("../types").IWebResponseCompatible<{
+    created_at: string;
+    created_by: string | null;
+    email: string | null;
+    herd_id: number;
+    id: number;
+    lifecycle: import("../types").Database["public"]["Enums"]["entity_lifecycle"];
+    lifecycle_changed_at: string;
+    lifecycle_changed_by: string | null;
+    lifecycle_reason: string | null;
+    name: string;
+    phone: string | null;
+    updated_at: string;
+    updated_by: string | null;
+}[]>>;
+export declare function server_get_contact_by_id(contact_id: number): Promise<import("../types").IWebResponseCompatible<{
+    created_at: string;
+    created_by: string | null;
+    email: string | null;
+    herd_id: number;
+    id: number;
+    lifecycle: import("../types").Database["public"]["Enums"]["entity_lifecycle"];
+    lifecycle_changed_at: string;
+    lifecycle_changed_by: string | null;
+    lifecycle_reason: string | null;
+    name: string;
+    phone: string | null;
+    updated_at: string;
+    updated_by: string | null;
+} | null>>;
+export declare function server_create_contact(row: ContactInsert): Promise<import("../types").IWebResponseCompatible<{
+    created_at: string;
+    created_by: string | null;
+    email: string | null;
+    herd_id: number;
+    id: number;
+    lifecycle: import("../types").Database["public"]["Enums"]["entity_lifecycle"];
+    lifecycle_changed_at: string;
+    lifecycle_changed_by: string | null;
+    lifecycle_reason: string | null;
+    name: string;
+    phone: string | null;
+    updated_at: string;
+    updated_by: string | null;
+} | null>>;
+export declare function server_update_contact(contact_id: number, patch: ContactUpdate): Promise<import("../types").IWebResponseCompatible<{
+    created_at: string;
+    created_by: string | null;
+    email: string | null;
+    herd_id: number;
+    id: number;
+    lifecycle: import("../types").Database["public"]["Enums"]["entity_lifecycle"];
+    lifecycle_changed_at: string;
+    lifecycle_changed_by: string | null;
+    lifecycle_reason: string | null;
+    name: string;
+    phone: string | null;
+    updated_at: string;
+    updated_by: string | null;
+} | null>>;

package/dist/helpers/contacts_server.js

@@ -0,0 +1,18 @@
+import { newServerClient } from "../supabase/server";
+import { create_contact, get_contact_by_id, get_contacts_by_herd_id, update_contact, } from "./contacts";
+export async function server_get_contacts_by_herd_id(herd_id, options) {
+    const client = await newServerClient();
+    return get_contacts_by_herd_id(client, herd_id, options);
+}
+export async function server_get_contact_by_id(contact_id) {
+    const client = await newServerClient();
+    return get_contact_by_id(client, contact_id);
+}
+export async function server_create_contact(row) {
+    const client = await newServerClient();
+    return create_contact(client, row);
+}
+export async function server_update_contact(contact_id, patch) {
+    const client = await newServerClient();
+    return update_contact(client, contact_id, patch);
+}

package/dist/helpers/deviceTransfer.js

@@ -1,14 +1,5 @@
-"use server";
 import { newServerClient } from "../supabase/server";
-import { IWebResponse } from "../types/requests";
+import { transfer_device_to_herd_query } from "./deviceTransfer.queries";
 export async function transferDeviceToHerd(deviceId, targetHerdId) {
-    const client = await newServerClient();
-    const { error } = await client.rpc("transfer_device_to_herd", {
-        p_device_id: deviceId,
-        p_target_herd_id: targetHerdId,
-    });
-    if (error) {
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    return IWebResponse.success(true).to_compatible();
+    return transfer_device_to_herd_query(await newServerClient(), deviceId, targetHerdId);
 }

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

@@ -0,0 +1,4 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { IWebResponseCompatible } from "../types/requests";
+import { Database } from "../types/supabase";
+export declare function transfer_device_to_herd_query(client: SupabaseClient<Database>, deviceId: number, targetHerdId: number): Promise<IWebResponseCompatible<boolean>>;

package/dist/helpers/deviceTransfer.queries.js

@@ -0,0 +1,11 @@
+import { IWebResponse } from "../types/requests";
+export async function transfer_device_to_herd_query(client, deviceId, targetHerdId) {
+    const { error } = await client.rpc("transfer_device_to_herd", {
+        p_device_id: deviceId,
+        p_target_herd_id: targetHerdId,
+    });
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    return IWebResponse.success(true).to_compatible();
+}

package/dist/helpers/devices.js

@@ -1,71 +1,14 @@
-"use server";
 import { newServerClient } from "../supabase/server";
-import { IWebResponse } from "../types/requests";
-import { get_devices_by_herd_query } from "./devices.queries";
+import { create_device_query, delete_device_by_id_query, get_devices_by_herd_query, update_device_query, } from "./devices.queries";
 export async function get_devices_by_herd(herd_id) {
     return get_devices_by_herd_query(await newServerClient(), herd_id);
 }
 export async function serverUpdateDevice(updatedDevice) {
-    // delete api keys, latitide, and longitude
-    const device_formatted = { ...updatedDevice };
-    delete device_formatted.api_keys_scout;
-    const device_latitude = device_formatted.latitude;
-    const device_longitude = device_formatted.longitude;
-    delete device_formatted.latitude;
-    delete device_formatted.longitude;
-    delete device_formatted.recent_events;
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("devices")
-        .update(device_formatted)
-        .match({ id: device_formatted.id })
-        .select("*");
-    if (error) {
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    else {
-        const updatedDevice = {
-            ...data[0],
-            latitude: device_latitude,
-            longitude: device_longitude,
-        };
-        return IWebResponse.success(updatedDevice).to_compatible();
-    }
+    return update_device_query(await newServerClient(), updatedDevice);
 }
 export async function serverCreateDevice(newDevice) {
-    const supabase = await newServerClient();
-    const user = await supabase.auth.getUser();
-    const userId = user?.data?.user?.id;
-    if (!userId) {
-        return IWebResponse.error("User not found").to_compatible();
-    }
-    newDevice.created_by = userId;
-    // strip id field from herd object
-    const { data, error } = await supabase
-        .from("devices")
-        .insert([newDevice])
-        .select("*");
-    if (error) {
-        // TODO: ALLOW PROPERTY INSTANTION OF CPMPATIBLE WEB RESPONSE
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    else {
-        const newDevice = { ...data[0], latitude: 0, longitude: 0 };
-        return IWebResponse.success(newDevice).to_compatible();
-    }
+    return create_device_query(await newServerClient(), newDevice);
 }
 export async function serverDeleteDeviceById(device_id) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("devices")
-        .delete()
-        .match({ id: device_id })
-        .select("*");
-    if (error) {
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    else {
-        const deletedDevice = { ...data[0], latitude: 0, longitude: 0 };
-        return IWebResponse.success(deletedDevice).to_compatible();
-    }
+    return delete_device_by_id_query(await newServerClient(), device_id);
 }

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

@@ -1,5 +1,8 @@
 import { SupabaseClient } from "@supabase/supabase-js";
-import { IDevice } from "../types/db";
+import { DeviceInsert, IDevice } from "../types/db";
 import { Database } from "../types/supabase";
 import { IWebResponseCompatible } from "../types/requests";
 export declare function get_devices_by_herd_query(client: SupabaseClient<Database>, herd_id: number): Promise<IWebResponseCompatible<IDevice[]>>;
+export declare function update_device_query(client: SupabaseClient<Database>, updatedDevice: IDevice): Promise<IWebResponseCompatible<IDevice | null>>;
+export declare function create_device_query(client: SupabaseClient<Database>, newDevice: DeviceInsert): Promise<IWebResponseCompatible<IDevice | null>>;
+export declare function delete_device_by_id_query(client: SupabaseClient<Database>, device_id: number): Promise<IWebResponseCompatible<IDevice | null>>;

package/dist/helpers/devices.queries.js

@@ -8,3 +8,55 @@ export async function get_devices_by_herd_query(client, herd_id) {
     }
     return IWebResponse.success(data).to_compatible();
 }
+export async function update_device_query(client, updatedDevice) {
+    const device_formatted = { ...updatedDevice };
+    delete device_formatted.api_keys_scout;
+    const device_latitude = device_formatted.latitude;
+    const device_longitude = device_formatted.longitude;
+    delete device_formatted.latitude;
+    delete device_formatted.longitude;
+    delete device_formatted.recent_events;
+    const { data, error } = await client
+        .from("devices")
+        .update(device_formatted)
+        .match({ id: device_formatted.id })
+        .select("*");
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    const updated = {
+        ...data[0],
+        latitude: device_latitude,
+        longitude: device_longitude,
+    };
+    return IWebResponse.success(updated).to_compatible();
+}
+export async function create_device_query(client, newDevice) {
+    const user = await client.auth.getUser();
+    const userId = user?.data?.user?.id;
+    if (!userId) {
+        return IWebResponse.error("User not found").to_compatible();
+    }
+    newDevice.created_by = userId;
+    const { data, error } = await client
+        .from("devices")
+        .insert([newDevice])
+        .select("*");
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    const created = { ...data[0], latitude: 0, longitude: 0 };
+    return IWebResponse.success(created).to_compatible();
+}
+export async function delete_device_by_id_query(client, device_id) {
+    const { data, error } = await client
+        .from("devices")
+        .delete()
+        .match({ id: device_id })
+        .select("*");
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    const deleted = { ...data[0], latitude: 0, longitude: 0 };
+    return IWebResponse.success(deleted).to_compatible();
+}

package/dist/helpers/document_templates.js

@@ -1,63 +1,17 @@
-"use server";
 import { newServerClient } from "../supabase/server";
-import { EnumWebResponse, IWebResponse, } from "../types/requests";
+import { create_document_template_query, get_document_template_by_id_query, get_document_templates_by_localization_query, get_document_templates_query, update_document_template_query, } from "./document_templates.queries";
 export async function server_get_document_templates() {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("document_templates")
-        .select("*")
-        .order("name");
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
-    }
-    return IWebResponse.success(data ?? []).to_compatible();
+    return get_document_templates_query(await newServerClient());
 }
 export async function server_get_document_template_by_id(template_id) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("document_templates")
-        .select("*")
-        .eq("id", template_id)
-        .maybeSingle();
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
-    }
-    return IWebResponse.success(data).to_compatible();
+    return get_document_template_by_id_query(await newServerClient(), template_id);
 }
 export async function server_get_document_templates_by_localization(localization_id) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("document_templates")
-        .select("*")
-        .eq("localization_id", localization_id)
-        .order("name");
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
-    }
-    return IWebResponse.success(data ?? []).to_compatible();
+    return get_document_templates_by_localization_query(await newServerClient(), localization_id);
 }
 export async function server_create_document_template(row) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("document_templates")
-        .insert(row)
-        .select("*")
-        .single();
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
-    }
-    return IWebResponse.success(data).to_compatible();
+    return create_document_template_query(await newServerClient(), row);
 }
 export async function server_update_document_template(template_id, updates) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("document_templates")
-        .update(updates)
-        .eq("id", template_id)
-        .select("*")
-        .single();
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
-    }
-    return IWebResponse.success(data).to_compatible();
+    return update_document_template_query(await newServerClient(), template_id, updates);
 }

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

@@ -0,0 +1,9 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { IDocumentTemplate, DocumentTemplateInsert, DocumentTemplateUpdate } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+import { Database } from "../types/supabase";
+export declare function get_document_templates_query(client: SupabaseClient<Database>): Promise<IWebResponseCompatible<IDocumentTemplate[]>>;
+export declare function get_document_template_by_id_query(client: SupabaseClient<Database>, template_id: number): Promise<IWebResponseCompatible<IDocumentTemplate | null>>;
+export declare function get_document_templates_by_localization_query(client: SupabaseClient<Database>, localization_id: number): Promise<IWebResponseCompatible<IDocumentTemplate[]>>;
+export declare function create_document_template_query(client: SupabaseClient<Database>, row: DocumentTemplateInsert): Promise<IWebResponseCompatible<IDocumentTemplate | null>>;
+export declare function update_document_template_query(client: SupabaseClient<Database>, template_id: number, updates: DocumentTemplateUpdate): Promise<IWebResponseCompatible<IDocumentTemplate | null>>;

package/dist/helpers/document_templates.queries.js

@@ -0,0 +1,56 @@
+import { EnumWebResponse, IWebResponse, } from "../types/requests";
+export async function get_document_templates_query(client) {
+    const { data, error } = await client
+        .from("document_templates")
+        .select("*")
+        .order("name");
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
+    }
+    return IWebResponse.success(data ?? []).to_compatible();
+}
+export async function get_document_template_by_id_query(client, template_id) {
+    const { data, error } = await client
+        .from("document_templates")
+        .select("*")
+        .eq("id", template_id)
+        .maybeSingle();
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function get_document_templates_by_localization_query(client, localization_id) {
+    const { data, error } = await client
+        .from("document_templates")
+        .select("*")
+        .eq("localization_id", localization_id)
+        .order("name");
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
+    }
+    return IWebResponse.success(data ?? []).to_compatible();
+}
+export async function create_document_template_query(client, row) {
+    const { data, error } = await client
+        .from("document_templates")
+        .insert(row)
+        .select("*")
+        .single();
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function update_document_template_query(client, template_id, updates) {
+    const { data, error } = await client
+        .from("document_templates")
+        .update(updates)
+        .eq("id", template_id)
+        .select("*")
+        .single();
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    return IWebResponse.success(data).to_compatible();
+}