@adventurelabs/scout-core 1.4.84 → 1.4.86

package/dist/api_keys/actions.d.ts

@@ -1,6 +1,7 @@
 import { IApiKeyScout } from "../types/db";
+import { SupabaseClient } from "@supabase/supabase-js";
 export declare function test_api_key_loading(device_id: number): Promise<boolean>;
 export declare function server_list_api_keys(device_id: number): Promise<IApiKeyScout[]>;
-export declare function server_list_api_keys_batch(device_ids: number[]): Promise<{
+export declare function server_list_api_keys_batch(device_ids: number[], client?: SupabaseClient): Promise<{
     [device_id: number]: IApiKeyScout[];
 }>;

package/dist/api_keys/actions.js

@@ -31,8 +31,8 @@ export async function server_list_api_keys(device_id) {
     }
     return data_to_return;
 }
-export async function server_list_api_keys_batch(device_ids) {
-    const supabase = await newServerClient();
+export async function server_list_api_keys_batch(device_ids, client) {
+    const supabase = client || (await newServerClient());
     // Check if the batch function exists by trying a simple call
     try {
         const { data, error } = await supabase.rpc("load_api_keys_batch", {

package/dist/helpers/contacts.d.ts

@@ -0,0 +1,10 @@
+import { Database } from "../types/supabase";
+import { IContact, ContactInsert, ContactUpdate } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+import { SupabaseClient } from "@supabase/supabase-js";
+export declare function get_contacts_by_herd_id(client: SupabaseClient<Database>, herd_id: number, options?: {
+    include_inactive?: boolean;
+}): Promise<IWebResponseCompatible<IContact[]>>;
+export declare function get_contact_by_id(client: SupabaseClient<Database>, contact_id: number): Promise<IWebResponseCompatible<IContact | null>>;
+export declare function create_contact(client: SupabaseClient<Database>, row: ContactInsert): Promise<IWebResponseCompatible<IContact | null>>;
+export declare function update_contact(client: SupabaseClient<Database>, contact_id: number, patch: ContactUpdate): Promise<IWebResponseCompatible<IContact | null>>;

package/dist/helpers/contacts.js

@@ -0,0 +1,71 @@
+import { IWebResponse } from "../types/requests";
+export async function get_contacts_by_herd_id(client, herd_id, options) {
+    let query = client.from("contacts").select("*").eq("herd_id", herd_id);
+    if (!options?.include_inactive) {
+        query = query.eq("lifecycle", "active");
+    }
+    const { data, error } = await query.order("name");
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    return IWebResponse.success(data ?? []).to_compatible();
+}
+export async function get_contact_by_id(client, contact_id) {
+    const { data, error } = await client
+        .from("contacts")
+        .select("*")
+        .eq("id", contact_id)
+        .maybeSingle();
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error("Contact not found")
+            .to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function create_contact(client, row) {
+    if (row.herd_id == null) {
+        return IWebResponse.error("herd_id is required")
+            .to_compatible();
+    }
+    if (!row.name?.trim()) {
+        return IWebResponse.error("name is required")
+            .to_compatible();
+    }
+    const { data, error } = await client
+        .from("contacts")
+        .insert([row])
+        .select("*")
+        .single();
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error("Failed to create contact")
+            .to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function update_contact(client, contact_id, patch) {
+    const { id: _id, herd_id: _hid, created_at: _ca, ...updateData } = patch;
+    if (Object.keys(updateData).length === 0) {
+        return IWebResponse.error("No valid fields to update")
+            .to_compatible();
+    }
+    const { data, error } = await client
+        .from("contacts")
+        .update(updateData)
+        .eq("id", contact_id)
+        .select("*")
+        .single();
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error("Contact not found")
+            .to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}

package/dist/helpers/document_templates.d.ts

@@ -0,0 +1,7 @@
+import { IDocumentTemplate, DocumentTemplateInsert, DocumentTemplateUpdate } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+export declare function server_get_document_templates(): Promise<IWebResponseCompatible<IDocumentTemplate[]>>;
+export declare function server_get_document_template_by_id(template_id: number): Promise<IWebResponseCompatible<IDocumentTemplate | null>>;
+export declare function server_get_document_templates_by_localization(localization_id: number): Promise<IWebResponseCompatible<IDocumentTemplate[]>>;
+export declare function server_create_document_template(row: DocumentTemplateInsert): Promise<IWebResponseCompatible<IDocumentTemplate | null>>;
+export declare function server_update_document_template(template_id: number, updates: DocumentTemplateUpdate): Promise<IWebResponseCompatible<IDocumentTemplate | null>>;

package/dist/helpers/document_templates.js

@@ -0,0 +1,63 @@
+"use server";
+import { newServerClient } from "../supabase/server";
+import { EnumWebResponse, IWebResponse, } from "../types/requests";
+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();
+}
+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();
+}
+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();
+}
+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();
+}
+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();
+}

package/dist/helpers/documents.d.ts

@@ -0,0 +1,12 @@
+import { Database } from "../types/supabase";
+import { IDocument, DocumentInsert, DocumentUpdate } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+import { SupabaseClient } from "@supabase/supabase-js";
+export declare function get_documents_by_herd_id(client: SupabaseClient<Database>, herd_id: number): Promise<IWebResponseCompatible<IDocument[]>>;
+export declare function get_documents_by_device_id(client: SupabaseClient<Database>, device_id: number): Promise<IWebResponseCompatible<IDocument[]>>;
+export declare function get_documents_by_user_id(client: SupabaseClient<Database>, user_id: string): Promise<IWebResponseCompatible<IDocument[]>>;
+export declare function get_documents_by_product_id(client: SupabaseClient<Database>, product_id: number): Promise<IWebResponseCompatible<IDocument[]>>;
+export declare function get_document_by_id(client: SupabaseClient<Database>, document_id: number): Promise<IWebResponseCompatible<IDocument | null>>;
+export declare function create_document(client: SupabaseClient<Database>, row: DocumentInsert): Promise<IWebResponseCompatible<IDocument | null>>;
+export declare function update_document(client: SupabaseClient<Database>, document_id: number, patch: DocumentUpdate): Promise<IWebResponseCompatible<IDocument | null>>;
+export declare function delete_document(client: SupabaseClient<Database>, document_id: number): Promise<IWebResponseCompatible<IDocument | null>>;

package/dist/helpers/documents.js

@@ -0,0 +1,107 @@
+import { IWebResponse } from "../types/requests";
+function assert_document_insert(row) {
+    if (!row.uri?.trim()) {
+        return IWebResponse.error("uri is required")
+            .to_compatible();
+    }
+    const owners = [row.user_id, row.herd_id, row.device_id, row.product_id];
+    const owner_count = owners.filter((owner) => owner != null).length;
+    if (owner_count !== 1) {
+        return IWebResponse.error("exactly one of user_id, herd_id, device_id, or product_id is required").to_compatible();
+    }
+    return null;
+}
+async function get_documents_by(client, column, value) {
+    const { data, error } = await client
+        .from("documents")
+        .select("*")
+        .eq(column, value)
+        .order("created_at", { ascending: false });
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    return IWebResponse.success(data ?? []).to_compatible();
+}
+export async function get_documents_by_herd_id(client, herd_id) {
+    return get_documents_by(client, "herd_id", herd_id);
+}
+export async function get_documents_by_device_id(client, device_id) {
+    return get_documents_by(client, "device_id", device_id);
+}
+export async function get_documents_by_user_id(client, user_id) {
+    return get_documents_by(client, "user_id", user_id);
+}
+export async function get_documents_by_product_id(client, product_id) {
+    return get_documents_by(client, "product_id", product_id);
+}
+export async function get_document_by_id(client, document_id) {
+    const { data, error } = await client
+        .from("documents")
+        .select("*")
+        .eq("id", document_id)
+        .maybeSingle();
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error("Document not found")
+            .to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function create_document(client, row) {
+    const invalid = assert_document_insert(row);
+    if (invalid) {
+        return invalid;
+    }
+    const { data, error } = await client
+        .from("documents")
+        .insert([row])
+        .select("*")
+        .single();
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error("Failed to create document")
+            .to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function update_document(client, document_id, patch) {
+    const { id: _id, created_at: _ca, created_by: _cb, ...updateData } = patch;
+    if (Object.keys(updateData).length === 0) {
+        return IWebResponse.error("No valid fields to update")
+            .to_compatible();
+    }
+    const { data, error } = await client
+        .from("documents")
+        .update(updateData)
+        .eq("id", document_id)
+        .select("*")
+        .single();
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error("Document not found")
+            .to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function delete_document(client, document_id) {
+    const { data, error } = await client
+        .from("documents")
+        .delete()
+        .eq("id", document_id)
+        .select("*")
+        .single();
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error("Document not found")
+            .to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}

package/dist/helpers/herds.js

@@ -1,7 +1,18 @@
 "use server";
+import { createHash } from "crypto";
 import { newServerClient } from "../supabase/server";
 import { EnumWebResponse, IWebResponse, } from "../types/requests";
-import { HerdModule, } from "../types/herd_module";
+import { LABELS } from "../constants/annotator";
+import { get_devices_by_herd } from "./devices";
+import { server_get_plans_by_herd_ids } from "./plans";
+import { server_get_layers_by_herd_ids } from "./layers";
+import { server_get_providers_by_herd_ids } from "./providers";
+import { server_get_users_with_herd_access_batch } from "./users";
+import { get_parts_by_herd_ids } from "./parts";
+import { server_get_more_zones_and_actions_for_herd } from "./zones";
+import { server_list_api_keys_batch } from "../api_keys/actions";
+import { server_get_session_summaries_by_herd } from "./session_summaries";
+import { server_get_session_usage_over_time_by_herd } from "./sessions";
 export async function get_herds(client) {
     const { data: herds } = await client.from("herds").select();
     if (!herds) {
@@ -71,12 +82,17 @@ export async function createHerd(newHerd) {
         return IWebResponse.success(true).to_compatible();
     }
 }
+// Stable hash of modules (queries return rows in a deterministic DB order), minus
+// the per-fetch timestamp, so the client can skip no-op updates without a deep walk.
+function hashHerdModules(modules) {
+    const stable = modules.map(({ timestamp_last_refreshed: _ts, ...rest }) => rest);
+    return createHash("sha1").update(JSON.stringify(stable)).digest("hex");
+}
 export async function server_load_herd_modules() {
     const startTime = Date.now();
-    const client_supabase = await newServerClient();
-    const herdsResult = await get_herds_with_location(client_supabase);
-    if (herdsResult.status !== EnumWebResponse.SUCCESS ||
-        !herdsResult.data) {
+    const client = await newServerClient();
+    const herdsResult = await get_herds_with_location(client);
+    if (herdsResult.status !== EnumWebResponse.SUCCESS || !herdsResult.data) {
         return {
             status: EnumWebResponse.ERROR,
             msg: herdsResult.msg ?? "Failed to load herds",
@@ -84,26 +100,88 @@ export async function server_load_herd_modules() {
             time_finished: Date.now(),
             time_sent: Date.now(),
             server_processing_time_ms: Date.now() - startTime,
+            content_hash: "",
         };
     }
     const herds = herdsResult.data.filter((h) => h.id != null);
-    const endTime = Date.now();
-    const totalLoadTime = endTime - startTime;
     if (herds.length === 0) {
-        console.log(`[server_load_herd_modules] No accessible herds (${totalLoadTime}ms)`);
+        const endTime = Date.now();
+        console.log(`[server_load_herd_modules] No accessible herds (${endTime - startTime}ms)`);
         return {
             status: EnumWebResponse.SUCCESS,
             msg: "No herds accessible",
             data: [],
             time_finished: endTime,
             time_sent: endTime,
-            server_processing_time_ms: totalLoadTime,
+            server_processing_time_ms: endTime - startTime,
+            content_hash: hashHerdModules([]),
         };
     }
-    const herdModulePromises = herds.map((herd) => HerdModule.from_herd(herd, client_supabase));
-    const new_herd_modules = await Promise.all(herdModulePromises);
-    const serialized_herd_modules = new_herd_modules.map((herd_module) => herd_module.to_serializable());
-    console.log(`[server_load_herd_modules] Loaded ${herds.length} herds in ${totalLoadTime}ms (parallel processing)`);
+    const herdIds = herds.map((h) => h.id);
+    // Run a per-herd RPC across all herds in parallel, tolerating individual failures.
+    const perHerd = (fn) => Promise.all(herds.map((h) => fn(h.id).catch(() => ({
+        status: EnumWebResponse.ERROR,
+        msg: "",
+        data: null,
+    }))));
+    const grouped = (p) => p.then((r) => r.data ?? {}).catch(() => ({}));
+    const [plansByHerd, layersByHerd, providersByHerd, usersByHerd, partsByDevice, devicesResults, zonesResults, summariesResults, usageResults,] = await Promise.all([
+        grouped(server_get_plans_by_herd_ids(herdIds, client)),
+        grouped(server_get_layers_by_herd_ids(herdIds, client)),
+        grouped(server_get_providers_by_herd_ids(herdIds, client)),
+        server_get_users_with_herd_access_batch(herdIds, client)
+            .then((r) => (r.status === EnumWebResponse.SUCCESS ? r.data : null))
+            .catch(() => null),
+        grouped(get_parts_by_herd_ids(client, herdIds)),
+        perHerd((id) => get_devices_by_herd(id, client)),
+        perHerd((id) => server_get_more_zones_and_actions_for_herd(id, 0, 10, client)),
+        perHerd((id) => server_get_session_summaries_by_herd(id, client)),
+        perHerd((id) => server_get_session_usage_over_time_by_herd(id, client)),
+    ]);
+    const devicesByHerdIndex = devicesResults.map((res) => res.status === EnumWebResponse.SUCCESS && res.data ? res.data : []);
+    const allDevices = devicesByHerdIndex.flat();
+    const allDeviceIds = allDevices.map((device) => device.id ?? 0);
+    let apiKeysByDevice = {};
+    if (allDeviceIds.length > 0) {
+        try {
+            apiKeysByDevice = await server_list_api_keys_batch(allDeviceIds, client);
+        }
+        catch (error) {
+            console.error(`[server_load_herd_modules] Failed to load API keys:`, error);
+        }
+    }
+    for (const device of allDevices) {
+        const deviceId = device.id ?? 0;
+        device.api_keys_scout = apiKeysByDevice[deviceId] || [];
+        device.parts = partsByDevice[deviceId] || [];
+    }
+    const serialized_herd_modules = herds.map((herd, index) => {
+        const zonesRes = zonesResults[index];
+        const summariesRes = summariesResults[index];
+        const usageRes = usageResults[index];
+        return {
+            herd,
+            devices: devicesByHerdIndex[index],
+            timestamp_last_refreshed: Date.now(),
+            user_roles: usersByHerd ? usersByHerd[herd.id] ?? [] : null,
+            labels: LABELS,
+            plans: plansByHerd[herd.id] ?? [],
+            zones: zonesRes.status === EnumWebResponse.SUCCESS && zonesRes.data
+                ? zonesRes.data
+                : [],
+            layers: layersByHerd[herd.id] ?? [],
+            providers: providersByHerd[herd.id] ?? [],
+            session_summaries: summariesRes.status === EnumWebResponse.SUCCESS && summariesRes.data
+                ? summariesRes.data
+                : null,
+            session_usage: usageRes.status === EnumWebResponse.SUCCESS && usageRes.data
+                ? usageRes.data
+                : null,
+        };
+    });
+    const endTime = Date.now();
+    const totalLoadTime = endTime - startTime;
+    console.log(`[server_load_herd_modules] Loaded ${herds.length} herds in ${totalLoadTime}ms (batched queries)`);
     return {
         status: EnumWebResponse.SUCCESS,
         msg: "Herd modules loaded successfully",
@@ -111,5 +189,6 @@ export async function server_load_herd_modules() {
         time_finished: endTime,
         time_sent: endTime,
         server_processing_time_ms: totalLoadTime,
+        content_hash: hashHerdModules(serialized_herd_modules),
     };
 }

package/dist/helpers/index.d.ts

@@ -3,7 +3,6 @@ export * from "./auth";
 export * from "./bounding_boxes";
 export * from "./chat";
 export * from "./certificates";
-export * from "./credentials";
 export * from "./user_credentials";
 export * from "./herd_credentials";
 export * from "./db";
@@ -17,6 +16,15 @@ export * from "./herds";
 export * from "./location";
 export * from "./lifecycle";
 export * from "./models";
+export * from "./manufacturers";
+export * from "./products";
+export * from "./product_numbers";
+export * from "./localizations";
+export * from "./issuers";
+export * from "./document_templates";
+export * from "./documents";
+export * from "./maintenance_requests";
+export * from "./contacts";
 export * from "./plans";
 export * from "./sessions";
 export * from "./segmentations_sam3";

package/dist/helpers/index.js

@@ -3,7 +3,6 @@ export * from "./auth";
 export * from "./bounding_boxes";
 export * from "./chat";
 export * from "./certificates";
-export * from "./credentials";
 export * from "./user_credentials";
 export * from "./herd_credentials";
 export * from "./db";
@@ -17,6 +16,15 @@ export * from "./herds";
 export * from "./location";
 export * from "./lifecycle";
 export * from "./models";
+export * from "./manufacturers";
+export * from "./products";
+export * from "./product_numbers";
+export * from "./localizations";
+export * from "./issuers";
+export * from "./document_templates";
+export * from "./documents";
+export * from "./maintenance_requests";
+export * from "./contacts";
 export * from "./plans";
 export * from "./sessions";
 export * from "./segmentations_sam3";

package/dist/helpers/issuers.d.ts

@@ -0,0 +1,7 @@
+import { IIssuer, IssuerInsert, IssuerUpdate } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+export declare function server_get_issuers(): Promise<IWebResponseCompatible<IIssuer[]>>;
+export declare function server_get_issuer_by_id(issuer_id: number): Promise<IWebResponseCompatible<IIssuer | null>>;
+export declare function server_get_issuers_by_localization(localization_id: number): Promise<IWebResponseCompatible<IIssuer[]>>;
+export declare function server_create_issuer(row: IssuerInsert): Promise<IWebResponseCompatible<IIssuer | null>>;
+export declare function server_update_issuer(issuer_id: number, updates: IssuerUpdate): Promise<IWebResponseCompatible<IIssuer | null>>;

package/dist/helpers/issuers.js

@@ -0,0 +1,63 @@
+"use server";
+import { newServerClient } from "../supabase/server";
+import { EnumWebResponse, IWebResponse, } from "../types/requests";
+export async function server_get_issuers() {
+    const supabase = await newServerClient();
+    const { data, error } = await supabase
+        .from("issuers")
+        .select("*")
+        .order("name");
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
+    }
+    return IWebResponse.success(data ?? []).to_compatible();
+}
+export async function server_get_issuer_by_id(issuer_id) {
+    const supabase = await newServerClient();
+    const { data, error } = await supabase
+        .from("issuers")
+        .select("*")
+        .eq("id", issuer_id)
+        .maybeSingle();
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function server_get_issuers_by_localization(localization_id) {
+    const supabase = await newServerClient();
+    const { data, error } = await supabase
+        .from("issuers")
+        .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 server_create_issuer(row) {
+    const supabase = await newServerClient();
+    const { data, error } = await supabase
+        .from("issuers")
+        .insert(row)
+        .select("*")
+        .single();
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function server_update_issuer(issuer_id, updates) {
+    const supabase = await newServerClient();
+    const { data, error } = await supabase
+        .from("issuers")
+        .update(updates)
+        .eq("id", issuer_id)
+        .select("*")
+        .single();
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    return IWebResponse.success(data).to_compatible();
+}

package/dist/helpers/layers.d.ts

@@ -1,3 +1,6 @@
+import { Database } from "../types/supabase";
 import { ILayer } from "../types/db";
 import { IWebResponseCompatible } from "../types/requests";
+import { SupabaseClient } from "@supabase/supabase-js";
 export declare function server_get_layers_by_herd(herd_id: number): Promise<IWebResponseCompatible<ILayer[]>>;
+export declare function server_get_layers_by_herd_ids(herd_ids: number[], client: SupabaseClient<Database>): Promise<IWebResponseCompatible<Record<number, ILayer[]>>>;

package/dist/helpers/layers.js

@@ -19,3 +19,23 @@ export async function server_get_layers_by_herd(herd_id) {
         return IWebResponse.success(data).to_compatible();
     }
 }
+// Fetches layers for many herds in one query, grouped by herd_id.
+export async function server_get_layers_by_herd_ids(herd_ids, client) {
+    var _a;
+    if (herd_ids.length === 0) {
+        return IWebResponse.success({}).to_compatible();
+    }
+    const { data, error } = await client
+        .from("layers")
+        .select("*")
+        .in("herd_id", herd_ids)
+        .order("id", { ascending: true });
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    const grouped = {};
+    for (const row of data ?? []) {
+        (grouped[_a = row.herd_id] ?? (grouped[_a] = [])).push(row);
+    }
+    return IWebResponse.success(grouped).to_compatible();
+}

package/dist/helpers/lifecycle.d.ts

@@ -1,6 +1,6 @@
 import { SupabaseClient } from "@supabase/supabase-js";
 import { Database } from "../types/supabase";
-import { EntityLifecycle, IArtifact, IDeviceRow, IEvent, IHerdAllowedDomain, IPart, ISession, IUserProfileRow, IUserRolePerHerd } from "../types/db";
+import { EntityLifecycle, IArtifact, IContact, IDeviceRow, IEvent, IHerdAllowedDomain, IPart, ISession, IUserProfileRow, IUserRolePerHerd } from "../types/db";
 import { IWebResponseCompatible } from "../types/requests";
 export interface LifecycleUpdateOptions {
     lifecycle_reason?: string | null;
@@ -15,4 +15,5 @@ export declare function update_part_lifecycle(client: SupabaseClient<Database>,
 export declare function update_event_lifecycle(client: SupabaseClient<Database>, event_id: number, lifecycle: EntityLifecycle, options?: LifecycleUpdateOptions): Promise<IWebResponseCompatible<IEvent | null>>;
 export declare function update_artifact_lifecycle(client: SupabaseClient<Database>, artifact_id: number, lifecycle: EntityLifecycle, options?: LifecycleUpdateOptions): Promise<IWebResponseCompatible<IArtifact | null>>;
 export declare function update_user_role_per_herd_lifecycle(client: SupabaseClient<Database>, membership_id: number, lifecycle: EntityLifecycle, options?: LifecycleUpdateOptions): Promise<IWebResponseCompatible<IUserRolePerHerd | null>>;
+export declare function update_contact_lifecycle(client: SupabaseClient<Database>, contact_id: number, lifecycle: EntityLifecycle, options?: LifecycleUpdateOptions): Promise<IWebResponseCompatible<IContact | null>>;
 export declare function update_herd_allowed_domain_lifecycle(client: SupabaseClient<Database>, domain_id: number, lifecycle: EntityLifecycle, options?: LifecycleUpdateOptions): Promise<IWebResponseCompatible<IHerdAllowedDomain | null>>;

package/dist/helpers/lifecycle.js

@@ -83,6 +83,15 @@ export async function update_user_role_per_herd_lifecycle(client, membership_id,
         .single();
     return lifecycle_result(data, error, "Herd membership not found or lifecycle update failed");
 }
+export async function update_contact_lifecycle(client, contact_id, lifecycle, options) {
+    const { data, error } = await client
+        .from("contacts")
+        .update(build_lifecycle_patch(lifecycle, options))
+        .eq("id", contact_id)
+        .select("*")
+        .single();
+    return lifecycle_result(data, error, "Contact not found or lifecycle update failed");
+}
 export async function update_herd_allowed_domain_lifecycle(client, domain_id, lifecycle, options) {
     const { data, error } = await client
         .from("herd_allowed_domains")

package/dist/helpers/localizations.d.ts

@@ -0,0 +1,6 @@
+import { ILocalization, LocalizationInsert, LocalizationUpdate } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+export declare function server_get_localizations(): Promise<IWebResponseCompatible<ILocalization[]>>;
+export declare function server_get_localization_by_id(localization_id: number): Promise<IWebResponseCompatible<ILocalization | null>>;
+export declare function server_create_localization(row: LocalizationInsert): Promise<IWebResponseCompatible<ILocalization | null>>;
+export declare function server_update_localization(localization_id: number, updates: LocalizationUpdate): Promise<IWebResponseCompatible<ILocalization | null>>;