@adventurelabs/scout-core 1.5.5 → 2.0.1

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

@@ -0,0 +1,9 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { IProduct, IProductNumber, ProductNumberInsert, ProductNumberUpdate } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+import { Database } from "../types/supabase";
+export declare function get_product_numbers_by_product_query(client: SupabaseClient<Database>, product_id: number): Promise<IWebResponseCompatible<IProductNumber[]>>;
+export declare function get_product_number_query(client: SupabaseClient<Database>, product_number: string): Promise<IWebResponseCompatible<IProductNumber | null>>;
+export declare function get_product_for_product_number_query(client: SupabaseClient<Database>, product_number: string): Promise<IWebResponseCompatible<IProduct | null>>;
+export declare function create_product_number_query(client: SupabaseClient<Database>, row: ProductNumberInsert): Promise<IWebResponseCompatible<IProductNumber | null>>;
+export declare function update_product_number_query(client: SupabaseClient<Database>, product_number: string, updates: ProductNumberUpdate): Promise<IWebResponseCompatible<IProductNumber | null>>;

package/dist/helpers/product_numbers.queries.js

@@ -0,0 +1,58 @@
+import { EnumWebResponse, IWebResponse, } from "../types/requests";
+export async function get_product_numbers_by_product_query(client, product_id) {
+    const { data, error } = await client
+        .from("product_numbers")
+        .select("*")
+        .eq("product_id", product_id)
+        .order("product_number");
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
+    }
+    return IWebResponse.success(data ?? []).to_compatible();
+}
+export async function get_product_number_query(client, product_number) {
+    const { data, error } = await client
+        .from("product_numbers")
+        .select("*")
+        .eq("product_number", product_number)
+        .maybeSingle();
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function get_product_for_product_number_query(client, product_number) {
+    const { data, error } = await client
+        .from("product_numbers")
+        .select("products!product_numbers_product_id_fkey(*)")
+        .eq("product_number", product_number)
+        .maybeSingle();
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    const product = data?.products ?? null;
+    return IWebResponse.success(product).to_compatible();
+}
+export async function create_product_number_query(client, row) {
+    const { data, error } = await client
+        .from("product_numbers")
+        .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_product_number_query(client, product_number, updates) {
+    const { data, error } = await client
+        .from("product_numbers")
+        .update(updates)
+        .eq("product_number", product_number)
+        .select("*")
+        .single();
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    return IWebResponse.success(data).to_compatible();
+}

package/dist/helpers/products.js

@@ -1,65 +1,17 @@
-"use server";
 import { newServerClient } from "../supabase/server";
-import { EnumWebResponse, IWebResponse, } from "../types/requests";
+import { create_product_query, get_product_by_id_query, get_products_by_manufacturer_query, get_products_query, update_product_query, } from "./products.queries";
 export async function server_get_products(options) {
-    const supabase = await newServerClient();
-    let query = supabase.from("products").select("*").order("name");
-    if (!options?.include_inactive) {
-        query = query.eq("lifecycle", "active");
-    }
-    const { data, error } = await query;
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
-    }
-    return IWebResponse.success(data ?? []).to_compatible();
+    return get_products_query(await newServerClient(), options);
 }
 export async function server_get_product_by_id(product_id) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("products")
-        .select("*")
-        .eq("id", product_id)
-        .maybeSingle();
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
-    }
-    return IWebResponse.success(data).to_compatible();
+    return get_product_by_id_query(await newServerClient(), product_id);
 }
 export async function server_get_products_by_manufacturer(manufacturer_id) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("products")
-        .select("*")
-        .eq("manufacturer_id", manufacturer_id)
-        .eq("lifecycle", "active")
-        .order("name");
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
-    }
-    return IWebResponse.success(data ?? []).to_compatible();
+    return get_products_by_manufacturer_query(await newServerClient(), manufacturer_id);
 }
 export async function server_create_product(row) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("products")
-        .insert(row)
-        .select("*")
-        .single();
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
-    }
-    return IWebResponse.success(data).to_compatible();
+    return create_product_query(await newServerClient(), row);
 }
 export async function server_update_product(product_id, updates) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("products")
-        .update(updates)
-        .eq("id", product_id)
-        .select("*")
-        .single();
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
-    }
-    return IWebResponse.success(data).to_compatible();
+    return update_product_query(await newServerClient(), product_id, updates);
 }

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

@@ -0,0 +1,11 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { IProduct, ProductInsert, ProductUpdate } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+import { Database } from "../types/supabase";
+export declare function get_products_query(client: SupabaseClient<Database>, options?: {
+    include_inactive?: boolean;
+}): Promise<IWebResponseCompatible<IProduct[]>>;
+export declare function get_product_by_id_query(client: SupabaseClient<Database>, product_id: number): Promise<IWebResponseCompatible<IProduct | null>>;
+export declare function get_products_by_manufacturer_query(client: SupabaseClient<Database>, manufacturer_id: number): Promise<IWebResponseCompatible<IProduct[]>>;
+export declare function create_product_query(client: SupabaseClient<Database>, row: ProductInsert): Promise<IWebResponseCompatible<IProduct | null>>;
+export declare function update_product_query(client: SupabaseClient<Database>, product_id: number, updates: ProductUpdate): Promise<IWebResponseCompatible<IProduct | null>>;

package/dist/helpers/products.queries.js

@@ -0,0 +1,58 @@
+import { EnumWebResponse, IWebResponse, } from "../types/requests";
+export async function get_products_query(client, options) {
+    let query = client.from("products").select("*").order("name");
+    if (!options?.include_inactive) {
+        query = query.eq("lifecycle", "active");
+    }
+    const { data, error } = await query;
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
+    }
+    return IWebResponse.success(data ?? []).to_compatible();
+}
+export async function get_product_by_id_query(client, product_id) {
+    const { data, error } = await client
+        .from("products")
+        .select("*")
+        .eq("id", product_id)
+        .maybeSingle();
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function get_products_by_manufacturer_query(client, manufacturer_id) {
+    const { data, error } = await client
+        .from("products")
+        .select("*")
+        .eq("manufacturer_id", manufacturer_id)
+        .eq("lifecycle", "active")
+        .order("name");
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
+    }
+    return IWebResponse.success(data ?? []).to_compatible();
+}
+export async function create_product_query(client, row) {
+    const { data, error } = await client
+        .from("products")
+        .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_product_query(client, product_id, updates) {
+    const { data, error } = await client
+        .from("products")
+        .update(updates)
+        .eq("id", product_id)
+        .select("*")
+        .single();
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    return IWebResponse.success(data).to_compatible();
+}

package/dist/helpers/providers.js

@@ -1,83 +1,17 @@
-"use server";
 import { newServerClient } from "../supabase/server";
-import { EnumWebResponse, IWebResponse, } from "../types/requests";
-import { get_providers_by_herd_ids_query } from "./herd_scoped.queries";
-// function that fetches the providers from our db given a herd id
+import { create_provider_query, delete_providers_by_ids_query, get_providers_by_herd_ids_query, get_providers_by_herd_query, update_provider_query, } from "./providers.queries";
 export async function server_get_providers_by_herd(herd_id) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("providers")
-        .select("*")
-        .eq("herd_id", herd_id);
-    if (error) {
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: null,
-        };
-    }
-    else {
-        return IWebResponse.success(data).to_compatible();
-    }
+    return get_providers_by_herd_query(await newServerClient(), herd_id);
 }
-// Fetches providers for many herds in one query, grouped by herd_id.
 export async function server_get_providers_by_herd_ids(herd_ids) {
     return get_providers_by_herd_ids_query(await newServerClient(), herd_ids);
 }
-// function that creates a new provider in our db
 export async function server_create_provider(provider) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("providers")
-        .insert(provider)
-        .select("*")
-        .single();
-    if (error) {
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: null,
-        };
-    }
-    else {
-        return IWebResponse.success(data).to_compatible();
-    }
+    return create_provider_query(await newServerClient(), provider);
 }
-// function that updates a provider in our db
 export async function server_update_provider(provider_id, updates) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("providers")
-        .update(updates)
-        .eq("id", provider_id)
-        .select("*")
-        .single();
-    if (error) {
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: null,
-        };
-    }
-    else {
-        return IWebResponse.success(data).to_compatible();
-    }
+    return update_provider_query(await newServerClient(), provider_id, updates);
 }
-// function that deletes providers by ids
 export async function server_delete_providers_by_ids(provider_ids) {
-    const supabase = await newServerClient();
-    const { error } = await supabase
-        .from("providers")
-        .delete()
-        .in("id", provider_ids);
-    if (error) {
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: false,
-        };
-    }
-    else {
-        return IWebResponse.success(true).to_compatible();
-    }
+    return delete_providers_by_ids_query(await newServerClient(), provider_ids);
 }

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

@@ -2,4 +2,8 @@ import { SupabaseClient } from "@supabase/supabase-js";
 import { IProvider } from "../types/db";
 import { Database } from "../types/supabase";
 import { IWebResponseCompatible } from "../types/requests";
-export declare function get_providers_by_herd_ids_query(client: SupabaseClient<Database>, herd_ids: number[]): Promise<IWebResponseCompatible<Record<number, IProvider[]>>>;
+export { get_providers_by_herd_ids_query } from "./herd_scoped.queries";
+export declare function get_providers_by_herd_query(client: SupabaseClient<Database>, herd_id: number): Promise<IWebResponseCompatible<IProvider[]>>;
+export declare function create_provider_query(client: SupabaseClient<Database>, provider: Omit<IProvider, "id" | "created_at">): Promise<IWebResponseCompatible<IProvider>>;
+export declare function update_provider_query(client: SupabaseClient<Database>, provider_id: number, updates: Partial<Omit<IProvider, "id" | "created_at">>): Promise<IWebResponseCompatible<IProvider>>;
+export declare function delete_providers_by_ids_query(client: SupabaseClient<Database>, provider_ids: number[]): Promise<IWebResponseCompatible<boolean>>;

package/dist/helpers/providers.queries.js

@@ -1,20 +1,61 @@
 import { EnumWebResponse, IWebResponse, } from "../types/requests";
-export async function get_providers_by_herd_ids_query(client, herd_ids) {
-    var _a;
-    if (herd_ids.length === 0) {
-        return IWebResponse.success({}).to_compatible();
+export { get_providers_by_herd_ids_query } from "./herd_scoped.queries";
+export async function get_providers_by_herd_query(client, herd_id) {
+    const { data, error } = await client
+        .from("providers")
+        .select("*")
+        .eq("herd_id", herd_id);
+    if (error) {
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: null,
+        };
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function create_provider_query(client, provider) {
+    const { data, error } = await client
+        .from("providers")
+        .insert(provider)
+        .select("*")
+        .single();
+    if (error) {
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: null,
+        };
     }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function update_provider_query(client, provider_id, updates) {
     const { data, error } = await client
         .from("providers")
+        .update(updates)
+        .eq("id", provider_id)
         .select("*")
-        .in("herd_id", herd_ids)
-        .order("id", { ascending: true });
+        .single();
     if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+        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(data).to_compatible();
+}
+export async function delete_providers_by_ids_query(client, provider_ids) {
+    const { error } = await client
+        .from("providers")
+        .delete()
+        .in("id", provider_ids);
+    if (error) {
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: false,
+        };
     }
-    return IWebResponse.success(grouped).to_compatible();
+    return IWebResponse.success(true).to_compatible();
 }

package/dist/helpers/pubsub_token_server.d.ts

@@ -1,3 +1,4 @@
 import { IPubsubTokenMint } from "../types/pubsub_token";
 import { IWebResponseCompatible } from "../types/requests";
 export declare function server_mint_pubsub_token(): Promise<IWebResponseCompatible<IPubsubTokenMint>>;
+export declare function server_get_pubsub_jwt_public_keys(): Promise<IWebResponseCompatible<import("../types").IPubsubJwtPublicKeyEntry[]>>;

package/dist/helpers/pubsub_token_server.js

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

package/dist/helpers/segmentations_sam3.js

@@ -1,91 +1,18 @@
-"use server";
 import { newServerClient } from "../supabase/server";
-import { EnumWebResponse, IWebResponse, } from "../types/requests";
+import { get_segmentations_sam3_for_artifact_by_frame_index_query, get_segmentations_sam3_for_artifact_by_subject_id_query, get_segmentations_sam3_for_artifact_query, get_segmentations_sam3_for_event_query, } from "./segmentations_sam3.queries";
 /** SAM3 masks for an artifact; optional timestamp_observation range and max_elements (omit or null for no limit). */
 export async function server_get_segmentations_sam3_for_artifact(artifactId, options) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase.rpc("get_segmentations_sam3_for_artifact", {
-        artifact_id_caller: artifactId,
-        ...(options?.start_timestamp != null && {
-            start_timestamp_caller: options.start_timestamp,
-        }),
-        ...(options?.end_timestamp != null && {
-            end_timestamp_caller: options.end_timestamp,
-        }),
-        ...(options?.max_elements != null && {
-            max_elements_caller: options.max_elements,
-        }),
-    });
-    if (error) {
-        console.warn("Error fetching segmentations_sam3 for artifact:", error.message);
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: [],
-        };
-    }
-    return IWebResponse.success(data ?? []).to_compatible();
+    return get_segmentations_sam3_for_artifact_query(await newServerClient(), artifactId, options);
 }
 /** SAM3 masks for an event; optional timestamp_observation range and max_elements (omit or null for no limit). */
 export async function server_get_segmentations_sam3_for_event(eventId, options) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase.rpc("get_segmentations_sam3_for_event", {
-        event_id_caller: eventId,
-        ...(options?.start_timestamp != null && {
-            start_timestamp_caller: options.start_timestamp,
-        }),
-        ...(options?.end_timestamp != null && {
-            end_timestamp_caller: options.end_timestamp,
-        }),
-        ...(options?.max_elements != null && {
-            max_elements_caller: options.max_elements,
-        }),
-    });
-    if (error) {
-        console.warn("Error fetching segmentations_sam3 for event:", error.message);
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: [],
-        };
-    }
-    return IWebResponse.success(data ?? []).to_compatible();
+    return get_segmentations_sam3_for_event_query(await newServerClient(), eventId, options);
 }
 /** SAM3 masks for an artifact by inclusive frame_index range; optional min_conf and max_elements (omit or null for no limit on rows). */
 export async function server_get_segmentations_sam3_for_artifact_by_frame_index(artifactId, frameIndexStart, frameIndexEnd, minConf = null, maxElements = null) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase.rpc("get_segmentations_sam3_for_artifact_by_frame_index", {
-        artifact_id_caller: artifactId,
-        frame_index_start_caller: frameIndexStart,
-        frame_index_end_caller: frameIndexEnd,
-        ...(minConf != null && { min_conf_caller: minConf }),
-        ...(maxElements != null && { max_elements_caller: maxElements }),
-    });
-    if (error) {
-        console.warn("Error fetching segmentations_sam3 for artifact by frame index:", error.message);
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: [],
-        };
-    }
-    return IWebResponse.success(data ?? []).to_compatible();
+    return get_segmentations_sam3_for_artifact_by_frame_index_query(await newServerClient(), artifactId, frameIndexStart, frameIndexEnd, minConf, maxElements);
 }
 /** SAM3 masks for an artifact and subject_id; omit maxElements (or null) for no row limit. */
 export async function server_get_segmentations_sam3_for_artifact_by_subject_id(artifactId, subjectId, maxElements = null) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase.rpc("get_segmentations_sam3_for_artifact_by_subject_id", {
-        artifact_id_caller: artifactId,
-        subject_id_caller: subjectId,
-        ...(maxElements != null && { max_elements_caller: maxElements }),
-    });
-    if (error) {
-        console.warn("Error fetching segmentations_sam3 for artifact by subject id:", error.message);
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: [],
-        };
-    }
-    return IWebResponse.success(data ?? []).to_compatible();
+    return get_segmentations_sam3_for_artifact_by_subject_id_query(await newServerClient(), artifactId, subjectId, maxElements);
 }

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

@@ -0,0 +1,16 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { ISegmentationSam3Pretty } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+import { Database } from "../types/supabase";
+export declare function get_segmentations_sam3_for_artifact_query(client: SupabaseClient<Database>, artifactId: number, options?: {
+    start_timestamp?: string | null;
+    end_timestamp?: string | null;
+    max_elements?: number | null;
+}): Promise<IWebResponseCompatible<ISegmentationSam3Pretty[]>>;
+export declare function get_segmentations_sam3_for_event_query(client: SupabaseClient<Database>, eventId: number, options?: {
+    start_timestamp?: string | null;
+    end_timestamp?: string | null;
+    max_elements?: number | null;
+}): Promise<IWebResponseCompatible<ISegmentationSam3Pretty[]>>;
+export declare function get_segmentations_sam3_for_artifact_by_frame_index_query(client: SupabaseClient<Database>, artifactId: number, frameIndexStart: number, frameIndexEnd: number, minConf?: number | null, maxElements?: number | null): Promise<IWebResponseCompatible<ISegmentationSam3Pretty[]>>;
+export declare function get_segmentations_sam3_for_artifact_by_subject_id_query(client: SupabaseClient<Database>, artifactId: number, subjectId: number, maxElements?: number | null): Promise<IWebResponseCompatible<ISegmentationSam3Pretty[]>>;

package/dist/helpers/segmentations_sam3.queries.js

@@ -0,0 +1,81 @@
+import { EnumWebResponse, IWebResponse, } from "../types/requests";
+export async function get_segmentations_sam3_for_artifact_query(client, artifactId, options) {
+    const { data, error } = await client.rpc("get_segmentations_sam3_for_artifact", {
+        artifact_id_caller: artifactId,
+        ...(options?.start_timestamp != null && {
+            start_timestamp_caller: options.start_timestamp,
+        }),
+        ...(options?.end_timestamp != null && {
+            end_timestamp_caller: options.end_timestamp,
+        }),
+        ...(options?.max_elements != null && {
+            max_elements_caller: options.max_elements,
+        }),
+    });
+    if (error) {
+        console.warn("Error fetching segmentations_sam3 for artifact:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: [],
+        };
+    }
+    return IWebResponse.success(data ?? []).to_compatible();
+}
+export async function get_segmentations_sam3_for_event_query(client, eventId, options) {
+    const { data, error } = await client.rpc("get_segmentations_sam3_for_event", {
+        event_id_caller: eventId,
+        ...(options?.start_timestamp != null && {
+            start_timestamp_caller: options.start_timestamp,
+        }),
+        ...(options?.end_timestamp != null && {
+            end_timestamp_caller: options.end_timestamp,
+        }),
+        ...(options?.max_elements != null && {
+            max_elements_caller: options.max_elements,
+        }),
+    });
+    if (error) {
+        console.warn("Error fetching segmentations_sam3 for event:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: [],
+        };
+    }
+    return IWebResponse.success(data ?? []).to_compatible();
+}
+export async function get_segmentations_sam3_for_artifact_by_frame_index_query(client, artifactId, frameIndexStart, frameIndexEnd, minConf = null, maxElements = null) {
+    const { data, error } = await client.rpc("get_segmentations_sam3_for_artifact_by_frame_index", {
+        artifact_id_caller: artifactId,
+        frame_index_start_caller: frameIndexStart,
+        frame_index_end_caller: frameIndexEnd,
+        ...(minConf != null && { min_conf_caller: minConf }),
+        ...(maxElements != null && { max_elements_caller: maxElements }),
+    });
+    if (error) {
+        console.warn("Error fetching segmentations_sam3 for artifact by frame index:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: [],
+        };
+    }
+    return IWebResponse.success(data ?? []).to_compatible();
+}
+export async function get_segmentations_sam3_for_artifact_by_subject_id_query(client, artifactId, subjectId, maxElements = null) {
+    const { data, error } = await client.rpc("get_segmentations_sam3_for_artifact_by_subject_id", {
+        artifact_id_caller: artifactId,
+        subject_id_caller: subjectId,
+        ...(maxElements != null && { max_elements_caller: maxElements }),
+    });
+    if (error) {
+        console.warn("Error fetching segmentations_sam3 for artifact by subject id:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: [],
+        };
+    }
+    return IWebResponse.success(data ?? []).to_compatible();
+}