@adventurelabs/scout-core 1.4.68 → 1.4.70

package/dist/helpers/herd_allowed_domains.d.ts

@@ -0,0 +1,5 @@
+import { Database } from "../types/supabase";
+import { IHerdAllowedDomain } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+import { SupabaseClient } from "@supabase/supabase-js";
+export declare function server_get_herd_allowed_domains(herd_id: number, supabaseClient?: SupabaseClient<Database>): Promise<IWebResponseCompatible<IHerdAllowedDomain[]>>;

package/dist/helpers/herd_allowed_domains.js

@@ -0,0 +1,15 @@
+"use server";
+import { newServerClient } from "../supabase/server";
+import { IWebResponse } from "../types/requests";
+export async function server_get_herd_allowed_domains(herd_id, supabaseClient) {
+    const supabase = supabaseClient ?? (await newServerClient());
+    const { data, error } = await supabase
+        .from("herd_allowed_domains")
+        .select("*")
+        .eq("herd_id", herd_id)
+        .order("domain", { ascending: true });
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    return IWebResponse.success(data ?? []).to_compatible();
+}

package/dist/helpers/herds.d.ts

@@ -7,5 +7,8 @@ export declare function get_herds(client: SupabaseClient<Database>): Promise<IWe
 export declare function get_herds_with_location(client: SupabaseClient<Database>): Promise<IWebResponseCompatible<IHerdPrettyLocation[]>>;
 export declare function get_herd_by_slug(slug: string): Promise<IWebResponseCompatible<IHerd>>;
 export declare function deleteHerd(herd_id: number): Promise<IWebResponseCompatible<boolean>>;
-export declare function createHerd(newHerd: any): Promise<IWebResponseCompatible<boolean>>;
+export declare function createHerd(newHerd: Omit<IHerd, "id" | "inserted_at"> & {
+    id?: number;
+    inserted_at?: string;
+}): Promise<IWebResponseCompatible<boolean>>;
 export declare function server_load_herd_modules(): Promise<IHerdModulesResponseWithStatus>;

package/dist/helpers/herds.js

@@ -66,11 +66,7 @@ export async function deleteHerd(herd_id) {
 }
 export async function createHerd(newHerd) {
     const supabase = await newServerClient();
-    const user = await supabase.auth.getUser();
-    const userId = user?.data?.user?.id;
-    newHerd.created_by = userId;
-    // strip id field from herd object
-    const { data, error } = await supabase.from("herds").insert([newHerd]);
+    const { error } = await supabase.from("herds").insert([newHerd]);
     if (error) {
         return {
             status: EnumWebResponse.ERROR,

package/dist/helpers/index.d.ts

@@ -13,6 +13,7 @@ export * from "./health_metrics";
 export * from "./heartbeats";
 export * from "./herds";
 export * from "./location";
+export * from "./lifecycle";
 export * from "./plans";
 export * from "./sessions";
 export * from "./segmentations_sam3";
@@ -30,4 +31,6 @@ export * from "./versions_software";
 export * from "./versions_software_server";
 export * from "./artifacts";
 export * from "./pins";
+export * from "./pubsub_token";
+export * from "./pubsub_token_server";
 export * from "./storagePath";

package/dist/helpers/index.js

@@ -13,6 +13,7 @@ export * from "./health_metrics";
 export * from "./heartbeats";
 export * from "./herds";
 export * from "./location";
+export * from "./lifecycle";
 export * from "./plans";
 export * from "./sessions";
 export * from "./segmentations_sam3";
@@ -30,4 +31,6 @@ export * from "./versions_software";
 export * from "./versions_software_server";
 export * from "./artifacts";
 export * from "./pins";
+export * from "./pubsub_token";
+export * from "./pubsub_token_server";
 export * from "./storagePath";

package/dist/helpers/invitations.d.ts

@@ -0,0 +1,8 @@
+import { Database } from "../types/supabase";
+import { IHerdInvitation, Role } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+import { SupabaseClient } from "@supabase/supabase-js";
+export declare function server_create_herd_invitation(herd_id: number, email: string, role: Role, expires_at?: string | null): Promise<IWebResponseCompatible<IHerdInvitation | null>>;
+export declare function accept_herd_invitations_for_current_user(invitation_ids: number[], supabaseClient?: SupabaseClient<Database>): Promise<IWebResponseCompatible<IHerdInvitation[]>>;
+export declare function server_get_herd_invitations_for_current_user(): Promise<IWebResponseCompatible<IHerdInvitation[]>>;
+export declare function server_get_herd_invitations_by_herd(herd_id: number, supabaseClient?: SupabaseClient<Database>): Promise<IWebResponseCompatible<IHerdInvitation[]>>;

package/dist/helpers/invitations.js

@@ -0,0 +1,47 @@
+"use server";
+import { newServerClient } from "../supabase/server";
+import { IWebResponse } from "../types/requests";
+export async function server_create_herd_invitation(herd_id, email, role, expires_at) {
+    const supabase = await newServerClient();
+    const { data, error } = await supabase.rpc("create_herd_invitation", {
+        p_herd_id: herd_id,
+        p_email: email,
+        p_role: role,
+        p_expires_at: expires_at ?? undefined,
+    });
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function accept_herd_invitations_for_current_user(invitation_ids, supabaseClient) {
+    if (invitation_ids.length === 0) {
+        return IWebResponse.error("At least one invitation id is required").to_compatible();
+    }
+    const supabase = supabaseClient ?? (await newServerClient());
+    const { data, error } = await supabase.rpc("accept_herd_invitations_for_current_user", { p_invitation_ids: invitation_ids });
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    return IWebResponse.success(data ?? []).to_compatible();
+}
+export async function server_get_herd_invitations_for_current_user() {
+    const supabase = await newServerClient();
+    const { data, error } = await supabase.rpc("get_herd_invitations_for_current_user");
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    return IWebResponse.success(data ?? []).to_compatible();
+}
+export async function server_get_herd_invitations_by_herd(herd_id, supabaseClient) {
+    const supabase = supabaseClient ?? (await newServerClient());
+    const { data, error } = await supabase
+        .from("herd_invitations")
+        .select("*")
+        .eq("herd_id", herd_id)
+        .order("created_at", { ascending: false });
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    return IWebResponse.success(data ?? []).to_compatible();
+}

package/dist/helpers/lifecycle.d.ts

@@ -0,0 +1,14 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { Database } from "../types/supabase";
+import { EntityLifecycle, IArtifact, IDeviceRow, IEvent, IPart, ISession, IUserProfileRow } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+export interface LifecycleUpdateOptions {
+    lifecycle_reason?: string | null;
+    lifecycle_changed_by?: string | null;
+}
+export declare function update_user_lifecycle(client: SupabaseClient<Database>, user_id: string, lifecycle: EntityLifecycle, options?: LifecycleUpdateOptions): Promise<IWebResponseCompatible<IUserProfileRow | null>>;
+export declare function update_device_lifecycle(client: SupabaseClient<Database>, device_id: number, lifecycle: EntityLifecycle, options?: LifecycleUpdateOptions): Promise<IWebResponseCompatible<IDeviceRow | null>>;
+export declare function update_session_lifecycle(client: SupabaseClient<Database>, session_id: number, lifecycle: EntityLifecycle, options?: LifecycleUpdateOptions): Promise<IWebResponseCompatible<ISession | null>>;
+export declare function update_part_lifecycle(client: SupabaseClient<Database>, part_id: number, lifecycle: EntityLifecycle, options?: LifecycleUpdateOptions): Promise<IWebResponseCompatible<IPart | null>>;
+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>>;

package/dist/helpers/lifecycle.js

@@ -0,0 +1,74 @@
+import { IWebResponse } from "../types/requests";
+function build_lifecycle_patch(lifecycle, options) {
+    const patch = { lifecycle };
+    if (options && "lifecycle_reason" in options) {
+        patch.lifecycle_reason = options.lifecycle_reason ?? null;
+    }
+    if (options && "lifecycle_changed_by" in options) {
+        patch.lifecycle_changed_by = options.lifecycle_changed_by ?? null;
+    }
+    return patch;
+}
+function lifecycle_result(data, error, not_found_msg) {
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error(not_found_msg).to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function update_user_lifecycle(client, user_id, lifecycle, options) {
+    const { data, error } = await client
+        .from("users")
+        .update(build_lifecycle_patch(lifecycle, options))
+        .eq("id", user_id)
+        .select("*")
+        .single();
+    return lifecycle_result(data, error, "User not found or lifecycle update failed");
+}
+export async function update_device_lifecycle(client, device_id, lifecycle, options) {
+    const { data, error } = await client
+        .from("devices")
+        .update(build_lifecycle_patch(lifecycle, options))
+        .eq("id", device_id)
+        .select("*")
+        .single();
+    return lifecycle_result(data, error, "Device not found or lifecycle update failed");
+}
+export async function update_session_lifecycle(client, session_id, lifecycle, options) {
+    const { data, error } = await client
+        .from("sessions")
+        .update(build_lifecycle_patch(lifecycle, options))
+        .eq("id", session_id)
+        .select("*")
+        .single();
+    return lifecycle_result(data, error, "Session not found or lifecycle update failed");
+}
+export async function update_part_lifecycle(client, part_id, lifecycle, options) {
+    const { data, error } = await client
+        .from("parts")
+        .update(build_lifecycle_patch(lifecycle, options))
+        .eq("id", part_id)
+        .select("*")
+        .single();
+    return lifecycle_result(data, error, "Part not found or lifecycle update failed");
+}
+export async function update_event_lifecycle(client, event_id, lifecycle, options) {
+    const { data, error } = await client
+        .from("events")
+        .update(build_lifecycle_patch(lifecycle, options))
+        .eq("id", event_id)
+        .select("*")
+        .single();
+    return lifecycle_result(data, error, "Event not found or lifecycle update failed");
+}
+export async function update_artifact_lifecycle(client, artifact_id, lifecycle, options) {
+    const { data, error } = await client
+        .from("artifacts")
+        .update(build_lifecycle_patch(lifecycle, options))
+        .eq("id", artifact_id)
+        .select("*")
+        .single();
+    return lifecycle_result(data, error, "Artifact not found or lifecycle update failed");
+}

package/dist/helpers/parts.d.ts

@@ -1,7 +1,8 @@
 import { Database } from "../types/supabase";
-import { IPart, PartInsert } from "../types/db";
+import { EntityLifecycle, IPart, PartInsert } from "../types/db";
 import { IWebResponseCompatible } from "../types/requests";
 import { SupabaseClient } from "@supabase/supabase-js";
+import { LifecycleUpdateOptions } from "./lifecycle";
 /**
  * Retrieves all active parts for a specific device
  * @param client - Supabase client instance
@@ -27,11 +28,13 @@ export declare function get_parts_by_serial_number(client: SupabaseClient<Databa
  */
 export declare function get_parts_by_product_number(client: SupabaseClient<Database>, product_number: string): Promise<IWebResponseCompatible<IPart[]>>;
 /**
- * Retrieves all active parts with a specific status
+ * Retrieves all parts with a specific lifecycle state
  * @param client - Supabase client instance
- * @param status - Component status to filter by
+ * @param lifecycle - Lifecycle state to filter by
  */
-export declare function get_parts_by_status(client: SupabaseClient<Database>, status: Database["public"]["Enums"]["component_status"]): Promise<IWebResponseCompatible<IPart[]>>;
+export declare function get_parts_by_lifecycle(client: SupabaseClient<Database>, lifecycle: EntityLifecycle): Promise<IWebResponseCompatible<IPart[]>>;
+/** @deprecated Use get_parts_by_lifecycle */
+export declare const get_parts_by_status: typeof get_parts_by_lifecycle;
 /**
  * Creates a new part with validation
  * @param client - Supabase client instance
@@ -46,18 +49,20 @@ export declare function create_part(client: SupabaseClient<Database>, newPart: P
  */
 export declare function update_part(client: SupabaseClient<Database>, part_id: number, updatedPart: Partial<PartInsert>): Promise<IWebResponseCompatible<IPart | null>>;
 /**
- * Soft deletes a part by setting deleted_at timestamp
+ * Marks an active part as deleted (lifecycle)
  * @param client - Supabase client instance
  * @param part_id - ID of the part to delete
+ * @param options - Optional lifecycle metadata
  */
-export declare function delete_part(client: SupabaseClient<Database>, part_id: number): Promise<IWebResponseCompatible<IPart | null>>;
+export declare function delete_part(client: SupabaseClient<Database>, part_id: number, options?: LifecycleUpdateOptions): Promise<IWebResponseCompatible<IPart | null>>;
 /**
- * Updates the status of a specific part
+ * Updates the lifecycle of a specific part
  * @param client - Supabase client instance
  * @param part_id - ID of the part to update
- * @param status - New status to set
+ * @param lifecycle - New lifecycle state
+ * @param options - Optional lifecycle metadata
  */
-export declare function update_part_status(client: SupabaseClient<Database>, part_id: number, status: Database["public"]["Enums"]["component_status"]): Promise<IWebResponseCompatible<IPart | null>>;
+export declare function update_part_status(client: SupabaseClient<Database>, part_id: number, lifecycle: EntityLifecycle, options?: LifecycleUpdateOptions): Promise<IWebResponseCompatible<IPart | null>>;
 /**
  * Retrieves all active parts associated with a certificate
  * @param client - Supabase client instance
@@ -71,19 +76,20 @@ export declare function get_parts_by_certificate_id(client: SupabaseClient<Datab
  */
 export declare function get_parts_by_herd_id(client: SupabaseClient<Database>, herd_id: number): Promise<IWebResponseCompatible<IPart[]>>;
 /**
- * Restores a soft-deleted part by clearing deleted_at timestamp
+ * Restores a deleted part to active lifecycle
  * @param client - Supabase client instance
  * @param part_id - ID of the part to restore
+ * @param options - Optional lifecycle metadata
  */
-export declare function restore_part(client: SupabaseClient<Database>, part_id: number): Promise<IWebResponseCompatible<IPart | null>>;
+export declare function restore_part(client: SupabaseClient<Database>, part_id: number, options?: LifecycleUpdateOptions): Promise<IWebResponseCompatible<IPart | null>>;
 /**
- * Permanently deletes a soft-deleted part from database
+ * Permanently deletes a part that is already in deleted lifecycle
  * @param client - Supabase client instance
  * @param part_id - ID of the part to permanently delete
  */
 export declare function hard_delete_part(client: SupabaseClient<Database>, part_id: number): Promise<IWebResponseCompatible<IPart | null>>;
 /**
- * Retrieves all soft-deleted parts for a specific device
+ * Retrieves all deleted parts for a specific device
  * @param client - Supabase client instance
  * @param device_id - ID of the device to get deleted parts for
  */

package/dist/helpers/parts.js

@@ -1,4 +1,5 @@
 import { IWebResponse } from "../types/requests";
+import { update_part_lifecycle } from "./lifecycle";
 /**
  * Retrieves all active parts for a specific device
  * @param client - Supabase client instance
@@ -9,7 +10,7 @@ export async function get_parts_by_device_id(client, device_id) {
         .from("parts")
         .select("*")
         .eq("device_id", device_id)
-        .is("deleted_at", null)
+        .eq("lifecycle", "active")
         .order("created_at", { ascending: false });
     if (error) {
         return IWebResponse.error(error.message).to_compatible();
@@ -29,7 +30,7 @@ export async function get_part_by_id(client, part_id) {
         .from("parts")
         .select("*")
         .eq("id", part_id)
-        .is("deleted_at", null)
+        .eq("lifecycle", "active")
         .single();
     if (error) {
         return IWebResponse.error(error.message).to_compatible();
@@ -49,7 +50,7 @@ export async function get_parts_by_serial_number(client, serial_number) {
         .from("parts")
         .select("*")
         .eq("serial_number", serial_number)
-        .is("deleted_at", null)
+        .eq("lifecycle", "active")
         .order("created_at", { ascending: false });
     if (error) {
         return IWebResponse.error(error.message).to_compatible();
@@ -69,7 +70,7 @@ export async function get_parts_by_product_number(client, product_number) {
         .from("parts")
         .select("*")
         .eq("product_number", product_number)
-        .is("deleted_at", null)
+        .eq("lifecycle", "active")
         .order("created_at", { ascending: false });
     if (error) {
         return IWebResponse.error(error.message).to_compatible();
@@ -80,25 +81,26 @@ export async function get_parts_by_product_number(client, product_number) {
     return IWebResponse.success(data).to_compatible();
 }
 /**
- * Retrieves all active parts with a specific status
+ * Retrieves all parts with a specific lifecycle state
  * @param client - Supabase client instance
- * @param status - Component status to filter by
+ * @param lifecycle - Lifecycle state to filter by
  */
-export async function get_parts_by_status(client, status) {
+export async function get_parts_by_lifecycle(client, lifecycle) {
     const { data, error } = await client
         .from("parts")
         .select("*")
-        .eq("status", status)
-        .is("deleted_at", null)
+        .eq("lifecycle", lifecycle)
         .order("created_at", { ascending: false });
     if (error) {
         return IWebResponse.error(error.message).to_compatible();
     }
     if (!data) {
-        return IWebResponse.error(`No parts found with status: ${status}`).to_compatible();
+        return IWebResponse.error(`No parts found with lifecycle: ${lifecycle}`).to_compatible();
     }
     return IWebResponse.success(data).to_compatible();
 }
+/** @deprecated Use get_parts_by_lifecycle */
+export const get_parts_by_status = get_parts_by_lifecycle;
 /**
  * Creates a new part with validation
  * @param client - Supabase client instance
@@ -154,17 +156,25 @@ export async function update_part(client, part_id, updatedPart) {
     return IWebResponse.success(data).to_compatible();
 }
 /**
- * Soft deletes a part by setting deleted_at timestamp
+ * Marks an active part as deleted (lifecycle)
  * @param client - Supabase client instance
  * @param part_id - ID of the part to delete
+ * @param options - Optional lifecycle metadata
  */
-export async function delete_part(client, part_id) {
-    // Soft delete by setting deleted_at timestamp
+export async function delete_part(client, part_id, options) {
     const { data, error } = await client
         .from("parts")
-        .update({ deleted_at: new Date().toISOString() })
+        .update({
+        lifecycle: "deleted",
+        ...(options?.lifecycle_reason !== undefined && {
+            lifecycle_reason: options.lifecycle_reason,
+        }),
+        ...(options?.lifecycle_changed_by !== undefined && {
+            lifecycle_changed_by: options.lifecycle_changed_by,
+        }),
+    })
         .eq("id", part_id)
-        .is("deleted_at", null)
+        .eq("lifecycle", "active")
         .select("*")
         .single();
     if (error) {
@@ -176,26 +186,14 @@ export async function delete_part(client, part_id) {
     return IWebResponse.success(data).to_compatible();
 }
 /**
- * Updates the status of a specific part
+ * Updates the lifecycle of a specific part
  * @param client - Supabase client instance
  * @param part_id - ID of the part to update
- * @param status - New status to set
+ * @param lifecycle - New lifecycle state
+ * @param options - Optional lifecycle metadata
  */
-export async function update_part_status(client, part_id, status) {
-    const { data, error } = await client
-        .from("parts")
-        .update({ status })
-        .eq("id", part_id)
-        .is("deleted_at", null)
-        .select("*")
-        .single();
-    if (error) {
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    if (!data) {
-        return IWebResponse.error("Part not found or status update failed").to_compatible();
-    }
-    return IWebResponse.success(data).to_compatible();
+export async function update_part_status(client, part_id, lifecycle, options) {
+    return update_part_lifecycle(client, part_id, lifecycle, options);
 }
 /**
  * Retrieves all active parts associated with a certificate
@@ -207,7 +205,7 @@ export async function get_parts_by_certificate_id(client, certificate_id) {
         .from("parts")
         .select("*")
         .eq("certificate_id", certificate_id)
-        .is("deleted_at", null)
+        .eq("lifecycle", "active")
         .order("created_at", { ascending: false });
     if (error) {
         return IWebResponse.error(error.message).to_compatible();
@@ -230,7 +228,7 @@ export async function get_parts_by_herd_id(client, herd_id) {
       devices!parts_device_id_fkey(herd_id)
     `)
         .eq("devices.herd_id", herd_id)
-        .is("deleted_at", null)
+        .eq("lifecycle", "active")
         .order("created_at", { ascending: false });
     if (error) {
         return IWebResponse.error(error.message).to_compatible();
@@ -241,17 +239,25 @@ export async function get_parts_by_herd_id(client, herd_id) {
     return IWebResponse.success(data).to_compatible();
 }
 /**
- * Restores a soft-deleted part by clearing deleted_at timestamp
+ * Restores a deleted part to active lifecycle
  * @param client - Supabase client instance
  * @param part_id - ID of the part to restore
+ * @param options - Optional lifecycle metadata
  */
-export async function restore_part(client, part_id) {
-    // Restore soft deleted part by setting deleted_at to null
+export async function restore_part(client, part_id, options) {
     const { data, error } = await client
         .from("parts")
-        .update({ deleted_at: null })
+        .update({
+        lifecycle: "active",
+        ...(options?.lifecycle_reason !== undefined && {
+            lifecycle_reason: options.lifecycle_reason,
+        }),
+        ...(options?.lifecycle_changed_by !== undefined && {
+            lifecycle_changed_by: options.lifecycle_changed_by,
+        }),
+    })
         .eq("id", part_id)
-        .not("deleted_at", "is", null)
+        .eq("lifecycle", "deleted")
         .select("*")
         .single();
     if (error) {
@@ -263,17 +269,16 @@ export async function restore_part(client, part_id) {
     return IWebResponse.success(data).to_compatible();
 }
 /**
- * Permanently deletes a soft-deleted part from database
+ * Permanently deletes a part that is already in deleted lifecycle
  * @param client - Supabase client instance
  * @param part_id - ID of the part to permanently delete
  */
 export async function hard_delete_part(client, part_id) {
-    // Permanently delete the part (only use for already soft-deleted parts)
     const { data, error } = await client
         .from("parts")
         .delete()
         .eq("id", part_id)
-        .not("deleted_at", "is", null)
+        .eq("lifecycle", "deleted")
         .select("*")
         .single();
     if (error) {
@@ -285,7 +290,7 @@ export async function hard_delete_part(client, part_id) {
     return IWebResponse.success(data).to_compatible();
 }
 /**
- * Retrieves all soft-deleted parts for a specific device
+ * Retrieves all deleted parts for a specific device
  * @param client - Supabase client instance
  * @param device_id - ID of the device to get deleted parts for
  */
@@ -294,8 +299,8 @@ export async function get_deleted_parts_by_device_id(client, device_id) {
         .from("parts")
         .select("*")
         .eq("device_id", device_id)
-        .not("deleted_at", "is", null)
-        .order("deleted_at", { ascending: false });
+        .eq("lifecycle", "deleted")
+        .order("lifecycle_changed_at", { ascending: false });
     if (error) {
         return IWebResponse.error(error.message).to_compatible();
     }
@@ -311,13 +316,12 @@ export async function get_deleted_parts_by_device_id(client, device_id) {
  * @param serial_number - Serial number to search for
  */
 export async function get_parts_by_product_and_serial(client, product_number, serial_number) {
-    // Get part by the composite unique constraint
     const { data, error } = await client
         .from("parts")
         .select("*")
         .eq("product_number", product_number)
         .eq("serial_number", serial_number)
-        .is("deleted_at", null)
+        .eq("lifecycle", "active")
         .single();
     if (error) {
         return IWebResponse.error(error.message).to_compatible();

package/dist/helpers/pubsub_token.d.ts

@@ -0,0 +1,5 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { Database } from "../types/supabase";
+import { IPubsubTokenMint } from "../types/pubsub_token";
+import { IWebResponseCompatible } from "../types/requests";
+export declare function mint_pubsub_token(client: SupabaseClient<Database>): Promise<IWebResponseCompatible<IPubsubTokenMint>>;

package/dist/helpers/pubsub_token.js

@@ -0,0 +1,14 @@
+import { IWebResponse } from "../types/requests";
+export async function mint_pubsub_token(client) {
+    const { data, error } = await client.functions.invoke("mint-pubsub-token", {
+        method: "POST",
+    });
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    const mint = data;
+    if (!mint?.token) {
+        return IWebResponse.error("mint-pubsub-token returned no token").to_compatible();
+    }
+    return IWebResponse.success(mint).to_compatible();
+}

package/dist/helpers/pubsub_token_server.d.ts

@@ -0,0 +1,7 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { Database } from "../types/supabase";
+import { IPubsubTokenMint } from "../types/pubsub_token";
+import { IWebResponseCompatible } from "../types/requests";
+export declare function server_mint_pubsub_token(options?: {
+    client?: SupabaseClient<Database>;
+}): Promise<IWebResponseCompatible<IPubsubTokenMint>>;

package/dist/helpers/pubsub_token_server.js

@@ -0,0 +1,7 @@
+"use server";
+import { newServerClient } from "../supabase/server";
+import { mint_pubsub_token } from "./pubsub_token";
+export async function server_mint_pubsub_token(options) {
+    const client = options?.client ?? (await newServerClient());
+    return mint_pubsub_token(client);
+}

package/dist/helpers/users.d.ts

@@ -1,7 +1,10 @@
-import { IUser, IUserAndRole, IUserRolePerHerd, Role } from "../types/db";
+import { IUser, IUserAndRole, IUserProfileRow, IUserRolePerHerd, Role } from "../types/db";
 import { IWebResponseCompatible } from "../types/requests";
 import { SupabaseClient } from "@supabase/supabase-js";
+import { Database } from "../types/supabase";
 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_upsert_user_with_role(herd_id: number, username: string, role: Role): 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>>;

package/dist/helpers/users.js

@@ -74,3 +74,18 @@ export async function server_upsert_user_with_role(herd_id, username, role) {
     }
     return IWebResponse.success({ user, role }).to_compatible();
 }
+export async function update_user_profile(client, user_id, patch) {
+    const { data, error } = await client
+        .from("users")
+        .update(patch)
+        .eq("id", user_id)
+        .select("*")
+        .single();
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error("User not found or profile update failed").to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}