@adventurelabs/scout-core 1.5.4 → 2.0.0

package/dist/helpers/layers.queries.js

@@ -1,20 +1,16 @@
 import { EnumWebResponse, IWebResponse, } from "../types/requests";
-export async function get_layers_by_herd_ids_query(client, herd_ids) {
-    var _a;
-    if (herd_ids.length === 0) {
-        return IWebResponse.success({}).to_compatible();
-    }
+export { get_layers_by_herd_ids_query } from "./herd_scoped.queries";
+export async function get_layers_by_herd_query(client, herd_id) {
     const { data, error } = await client
         .from("layers")
         .select("*")
-        .in("herd_id", herd_ids)
-        .order("id", { ascending: true });
+        .eq("herd_id", herd_id);
     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 {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: null,
+        };
     }
-    return IWebResponse.success(grouped).to_compatible();
+    return IWebResponse.success(data).to_compatible();
 }

package/dist/helpers/lifecycle_server.d.ts

@@ -0,0 +1,175 @@
+import { EntityLifecycle } from "../types/db";
+import { LifecycleUpdateOptions } from "./lifecycle";
+export declare function server_update_user_lifecycle(user_id: string, lifecycle: EntityLifecycle, options?: LifecycleUpdateOptions): Promise<import("../types").IWebResponseCompatible<{
+    auto_approve_sessions: boolean;
+    earthranger_id: string | null;
+    first: string | null;
+    id: string;
+    is_registered: boolean;
+    last: string | null;
+    lifecycle: import("../types").Database["public"]["Enums"]["entity_lifecycle"];
+    lifecycle_changed_at: string;
+    lifecycle_changed_by: string | null;
+    lifecycle_reason: string | null;
+    photo_uri: string | null;
+    signature_base64: string | null;
+    title: string | null;
+    username: string | null;
+} | null>>;
+export declare function server_update_device_lifecycle(device_id: number, lifecycle: EntityLifecycle, options?: LifecycleUpdateOptions): Promise<import("../types").IWebResponseCompatible<{
+    altitude: number | null;
+    color: string | null;
+    created_by: string;
+    description: string;
+    device_type: import("../types").Database["public"]["Enums"]["device_type"];
+    domain_name: string | null;
+    heading: number | null;
+    herd_id: number;
+    id: number;
+    inserted_at: string;
+    lifecycle: import("../types").Database["public"]["Enums"]["entity_lifecycle"];
+    lifecycle_changed_at: string;
+    lifecycle_changed_by: string | null;
+    lifecycle_reason: string | null;
+    location: unknown;
+    name: string;
+} | null>>;
+export declare function server_update_session_lifecycle(session_id: number, lifecycle: EntityLifecycle, options?: LifecycleUpdateOptions): Promise<import("../types").IWebResponseCompatible<{
+    altitude_average: number;
+    altitude_max: number;
+    altitude_min: number;
+    battery_id: number | null;
+    device_id: number;
+    distance_max_from_start: number;
+    distance_total: number;
+    end_approver: string | null;
+    end_reason: import("../types").Database["public"]["Enums"]["session_end_reason"] | null;
+    id: number;
+    inserted_at: string;
+    lifecycle: import("../types").Database["public"]["Enums"]["entity_lifecycle"];
+    lifecycle_changed_at: string;
+    lifecycle_changed_by: string | null;
+    lifecycle_reason: string | null;
+    locations: unknown;
+    post_approver: string | null;
+    software_version: string;
+    start_approver: string | null;
+    status: import("../types").Database["public"]["Enums"]["session_status"];
+    timestamp_end: string | null;
+    timestamp_start: string;
+    velocity_average: number;
+    velocity_max: number;
+    velocity_min: number;
+} | null>>;
+export declare function server_update_part_lifecycle(part_id: number, lifecycle: EntityLifecycle, options?: LifecycleUpdateOptions): Promise<import("../types").IWebResponseCompatible<{
+    certificate_id: number | null;
+    created_at: string;
+    device_id: number | null;
+    health: import("../types").Database["public"]["Enums"]["health_item"];
+    herd_id: number | null;
+    id: number;
+    lifecycle: import("../types").Database["public"]["Enums"]["entity_lifecycle"];
+    lifecycle_changed_at: string;
+    lifecycle_changed_by: string | null;
+    lifecycle_reason: string | null;
+    primary_calibration_id: number | null;
+    product_number: string;
+    serial_number: string;
+    updated_at: string | null;
+} | null>>;
+export declare function server_update_event_lifecycle(event_id: number, lifecycle: EntityLifecycle, options?: LifecycleUpdateOptions): Promise<import("../types").IWebResponseCompatible<{
+    altitude: number;
+    device_id: number;
+    earthranger_url: string | null;
+    embedded_at: string | null;
+    file_path: string | null;
+    heading: number;
+    id: number;
+    inserted_at: string;
+    is_public: boolean;
+    lifecycle: import("../types").Database["public"]["Enums"]["entity_lifecycle"];
+    lifecycle_changed_at: string;
+    lifecycle_changed_by: string | null;
+    lifecycle_reason: string | null;
+    location: unknown;
+    media_type: import("../types").Database["public"]["Enums"]["media_type"];
+    media_url: string | null;
+    message: string | null;
+    origin_heading: number | null;
+    origin_height: number | null;
+    origin_location: unknown;
+    origin_pitch: number | null;
+    origin_roll: number | null;
+    processing_blocked_at: string | null;
+    processing_blocked_reason: string | null;
+    segmented_at: string | null;
+    sensor_pitch: number | null;
+    sensor_roll: number | null;
+    sensor_yaw: number | null;
+    session_id: number | null;
+    tagged_at: string | null;
+    timestamp_observation: string;
+    tracked_at: string | null;
+} | null>>;
+export declare function server_update_artifact_lifecycle(artifact_id: number, lifecycle: EntityLifecycle, options?: LifecycleUpdateOptions): Promise<import("../types").IWebResponseCompatible<{
+    created_at: string;
+    device_id: number;
+    embedded_at: string | null;
+    file_path: string;
+    file_size_bytes: number | null;
+    id: number;
+    lifecycle: import("../types").Database["public"]["Enums"]["entity_lifecycle"];
+    lifecycle_changed_at: string;
+    lifecycle_changed_by: string | null;
+    lifecycle_reason: string | null;
+    modality: string | null;
+    processing_blocked_at: string | null;
+    processing_blocked_reason: string | null;
+    proxy_file_path: string | null;
+    proxy_generated_at: string | null;
+    segmented_at: string | null;
+    session_id: number | null;
+    tagged_at: string | null;
+    thumbnail_file_path: string | null;
+    thumbnail_generated_at: string | null;
+    timestamp_observation: string | null;
+    timestamp_observation_end: string;
+    tracked_at: string | null;
+    updated_at: string | null;
+} | null>>;
+export declare function server_update_user_role_per_herd_lifecycle(membership_id: number, lifecycle: EntityLifecycle, options?: LifecycleUpdateOptions): Promise<import("../types").IWebResponseCompatible<{
+    herd_id: number;
+    herd_role_id: number;
+    id: number;
+    inserted_at: string;
+    lifecycle: import("../types").Database["public"]["Enums"]["entity_lifecycle"];
+    lifecycle_changed_at: string;
+    lifecycle_changed_by: string | null;
+    lifecycle_reason: string | null;
+    user_id: string;
+} | null>>;
+export declare function server_update_contact_lifecycle(contact_id: number, lifecycle: EntityLifecycle, options?: LifecycleUpdateOptions): 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_herd_allowed_domain_lifecycle(domain_id: number, lifecycle: EntityLifecycle, options?: LifecycleUpdateOptions): Promise<import("../types").IWebResponseCompatible<{
+    created_at: string;
+    domain: string;
+    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;
+} | null>>;

package/dist/helpers/lifecycle_server.js

@@ -0,0 +1,38 @@
+import { newServerClient } from "../supabase/server";
+import { update_artifact_lifecycle, update_contact_lifecycle, update_device_lifecycle, update_event_lifecycle, update_herd_allowed_domain_lifecycle, update_part_lifecycle, update_session_lifecycle, update_user_lifecycle, update_user_role_per_herd_lifecycle, } from "./lifecycle";
+export async function server_update_user_lifecycle(user_id, lifecycle, options) {
+    const client = await newServerClient();
+    return update_user_lifecycle(client, user_id, lifecycle, options);
+}
+export async function server_update_device_lifecycle(device_id, lifecycle, options) {
+    const client = await newServerClient();
+    return update_device_lifecycle(client, device_id, lifecycle, options);
+}
+export async function server_update_session_lifecycle(session_id, lifecycle, options) {
+    const client = await newServerClient();
+    return update_session_lifecycle(client, session_id, lifecycle, options);
+}
+export async function server_update_part_lifecycle(part_id, lifecycle, options) {
+    const client = await newServerClient();
+    return update_part_lifecycle(client, part_id, lifecycle, options);
+}
+export async function server_update_event_lifecycle(event_id, lifecycle, options) {
+    const client = await newServerClient();
+    return update_event_lifecycle(client, event_id, lifecycle, options);
+}
+export async function server_update_artifact_lifecycle(artifact_id, lifecycle, options) {
+    const client = await newServerClient();
+    return update_artifact_lifecycle(client, artifact_id, lifecycle, options);
+}
+export async function server_update_user_role_per_herd_lifecycle(membership_id, lifecycle, options) {
+    const client = await newServerClient();
+    return update_user_role_per_herd_lifecycle(client, membership_id, lifecycle, options);
+}
+export async function server_update_contact_lifecycle(contact_id, lifecycle, options) {
+    const client = await newServerClient();
+    return update_contact_lifecycle(client, contact_id, lifecycle, options);
+}
+export async function server_update_herd_allowed_domain_lifecycle(domain_id, lifecycle, options) {
+    const client = await newServerClient();
+    return update_herd_allowed_domain_lifecycle(client, domain_id, lifecycle, options);
+}

package/dist/helpers/localizations.js

@@ -1,51 +1,14 @@
-"use server";
 import { newServerClient } from "../supabase/server";
-import { EnumWebResponse, IWebResponse, } from "../types/requests";
+import { create_localization_query, get_localization_by_id_query, get_localizations_query, update_localization_query, } from "./localizations.queries";
 export async function server_get_localizations() {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("localizations")
-        .select("*")
-        .order("region");
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
-    }
-    return IWebResponse.success(data ?? []).to_compatible();
+    return get_localizations_query(await newServerClient());
 }
 export async function server_get_localization_by_id(localization_id) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("localizations")
-        .select("*")
-        .eq("id", localization_id)
-        .maybeSingle();
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
-    }
-    return IWebResponse.success(data).to_compatible();
+    return get_localization_by_id_query(await newServerClient(), localization_id);
 }
 export async function server_create_localization(row) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("localizations")
-        .insert(row)
-        .select("*")
-        .single();
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
-    }
-    return IWebResponse.success(data).to_compatible();
+    return create_localization_query(await newServerClient(), row);
 }
 export async function server_update_localization(localization_id, updates) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("localizations")
-        .update(updates)
-        .eq("id", localization_id)
-        .select("*")
-        .single();
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
-    }
-    return IWebResponse.success(data).to_compatible();
+    return update_localization_query(await newServerClient(), localization_id, updates);
 }

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

@@ -0,0 +1,8 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { ILocalization, LocalizationInsert, LocalizationUpdate } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+import { Database } from "../types/supabase";
+export declare function get_localizations_query(client: SupabaseClient<Database>): Promise<IWebResponseCompatible<ILocalization[]>>;
+export declare function get_localization_by_id_query(client: SupabaseClient<Database>, localization_id: number): Promise<IWebResponseCompatible<ILocalization | null>>;
+export declare function create_localization_query(client: SupabaseClient<Database>, row: LocalizationInsert): Promise<IWebResponseCompatible<ILocalization | null>>;
+export declare function update_localization_query(client: SupabaseClient<Database>, localization_id: number, updates: LocalizationUpdate): Promise<IWebResponseCompatible<ILocalization | null>>;

package/dist/helpers/localizations.queries.js

@@ -0,0 +1,45 @@
+import { EnumWebResponse, IWebResponse, } from "../types/requests";
+export async function get_localizations_query(client) {
+    const { data, error } = await client
+        .from("localizations")
+        .select("*")
+        .order("region");
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
+    }
+    return IWebResponse.success(data ?? []).to_compatible();
+}
+export async function get_localization_by_id_query(client, localization_id) {
+    const { data, error } = await client
+        .from("localizations")
+        .select("*")
+        .eq("id", localization_id)
+        .maybeSingle();
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function create_localization_query(client, row) {
+    const { data, error } = await client
+        .from("localizations")
+        .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_localization_query(client, localization_id, updates) {
+    const { data, error } = await client
+        .from("localizations")
+        .update(updates)
+        .eq("id", localization_id)
+        .select("*")
+        .single();
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    return IWebResponse.success(data).to_compatible();
+}

package/dist/helpers/maintenance_requests_server.d.ts

@@ -0,0 +1,124 @@
+import { MaintenanceRequestInsert, MaintenanceRequestUpdate } from "../types/db";
+export declare function server_get_maintenance_requests_by_device_id(device_id: number): Promise<import("../types").IWebResponseCompatible<{
+    created_at: string;
+    creator_user_id: string | null;
+    defect_timestamp: string;
+    description: string;
+    device_id: number | null;
+    id: number;
+    image: string | null;
+    is_serviceable: boolean;
+    part_id: number | null;
+    remediation_completed_at: string | null;
+    remediation_completed_user_id: string | null;
+    remediation_notes: string | null;
+    session_incident_id: number | null;
+    updated_at: string | null;
+    updated_by_user_id: string | null;
+}[]>>;
+export declare function server_get_maintenance_requests_by_part_id(part_id: number): Promise<import("../types").IWebResponseCompatible<{
+    created_at: string;
+    creator_user_id: string | null;
+    defect_timestamp: string;
+    description: string;
+    device_id: number | null;
+    id: number;
+    image: string | null;
+    is_serviceable: boolean;
+    part_id: number | null;
+    remediation_completed_at: string | null;
+    remediation_completed_user_id: string | null;
+    remediation_notes: string | null;
+    session_incident_id: number | null;
+    updated_at: string | null;
+    updated_by_user_id: string | null;
+}[]>>;
+export declare function server_get_maintenance_requests_by_herd_id(herd_id: number, options?: {
+    limit?: number;
+    offset?: number;
+}): Promise<import("../types").IWebResponseCompatible<{
+    created_at: string;
+    creator_user_id: string | null;
+    defect_timestamp: string;
+    description: string;
+    device_id: number | null;
+    id: number;
+    image: string | null;
+    is_serviceable: boolean;
+    part_id: number | null;
+    remediation_completed_at: string | null;
+    remediation_completed_user_id: string | null;
+    remediation_notes: string | null;
+    session_incident_id: number | null;
+    updated_at: string | null;
+    updated_by_user_id: string | null;
+}[]>>;
+export declare function server_get_maintenance_requests_count_by_herd_id(herd_id: number): Promise<import("../types").IWebResponseCompatible<number>>;
+export declare function server_get_maintenance_request_by_id(request_id: number): Promise<import("../types").IWebResponseCompatible<{
+    created_at: string;
+    creator_user_id: string | null;
+    defect_timestamp: string;
+    description: string;
+    device_id: number | null;
+    id: number;
+    image: string | null;
+    is_serviceable: boolean;
+    part_id: number | null;
+    remediation_completed_at: string | null;
+    remediation_completed_user_id: string | null;
+    remediation_notes: string | null;
+    session_incident_id: number | null;
+    updated_at: string | null;
+    updated_by_user_id: string | null;
+} | null>>;
+export declare function server_create_maintenance_request(row: MaintenanceRequestInsert): Promise<import("../types").IWebResponseCompatible<{
+    created_at: string;
+    creator_user_id: string | null;
+    defect_timestamp: string;
+    description: string;
+    device_id: number | null;
+    id: number;
+    image: string | null;
+    is_serviceable: boolean;
+    part_id: number | null;
+    remediation_completed_at: string | null;
+    remediation_completed_user_id: string | null;
+    remediation_notes: string | null;
+    session_incident_id: number | null;
+    updated_at: string | null;
+    updated_by_user_id: string | null;
+} | null>>;
+export declare function server_update_maintenance_request(request_id: number, patch: MaintenanceRequestUpdate): Promise<import("../types").IWebResponseCompatible<{
+    created_at: string;
+    creator_user_id: string | null;
+    defect_timestamp: string;
+    description: string;
+    device_id: number | null;
+    id: number;
+    image: string | null;
+    is_serviceable: boolean;
+    part_id: number | null;
+    remediation_completed_at: string | null;
+    remediation_completed_user_id: string | null;
+    remediation_notes: string | null;
+    session_incident_id: number | null;
+    updated_at: string | null;
+    updated_by_user_id: string | null;
+} | null>>;
+export declare function server_delete_maintenance_request(request_id: number): Promise<import("../types").IWebResponseCompatible<{
+    created_at: string;
+    creator_user_id: string | null;
+    defect_timestamp: string;
+    description: string;
+    device_id: number | null;
+    id: number;
+    image: string | null;
+    is_serviceable: boolean;
+    part_id: number | null;
+    remediation_completed_at: string | null;
+    remediation_completed_user_id: string | null;
+    remediation_notes: string | null;
+    session_incident_id: number | null;
+    updated_at: string | null;
+    updated_by_user_id: string | null;
+} | null>>;

package/dist/helpers/maintenance_requests_server.js

@@ -0,0 +1,34 @@
+import { newServerClient } from "../supabase/server";
+import { create_maintenance_request, delete_maintenance_request, get_maintenance_request_by_id, get_maintenance_requests_by_device_id, get_maintenance_requests_by_herd_id, get_maintenance_requests_by_part_id, get_maintenance_requests_count_by_herd_id, update_maintenance_request, } from "./maintenance_requests";
+export async function server_get_maintenance_requests_by_device_id(device_id) {
+    const client = await newServerClient();
+    return get_maintenance_requests_by_device_id(client, device_id);
+}
+export async function server_get_maintenance_requests_by_part_id(part_id) {
+    const client = await newServerClient();
+    return get_maintenance_requests_by_part_id(client, part_id);
+}
+export async function server_get_maintenance_requests_by_herd_id(herd_id, options) {
+    const client = await newServerClient();
+    return get_maintenance_requests_by_herd_id(client, herd_id, options);
+}
+export async function server_get_maintenance_requests_count_by_herd_id(herd_id) {
+    const client = await newServerClient();
+    return get_maintenance_requests_count_by_herd_id(client, herd_id);
+}
+export async function server_get_maintenance_request_by_id(request_id) {
+    const client = await newServerClient();
+    return get_maintenance_request_by_id(client, request_id);
+}
+export async function server_create_maintenance_request(row) {
+    const client = await newServerClient();
+    return create_maintenance_request(client, row);
+}
+export async function server_update_maintenance_request(request_id, patch) {
+    const client = await newServerClient();
+    return update_maintenance_request(client, request_id, patch);
+}
+export async function server_delete_maintenance_request(request_id) {
+    const client = await newServerClient();
+    return delete_maintenance_request(client, request_id);
+}

package/dist/helpers/manufacturers.js

@@ -1,52 +1,14 @@
-"use server";
 import { newServerClient } from "../supabase/server";
-import { EnumWebResponse, IWebResponse, } from "../types/requests";
+import { create_manufacturer_query, get_manufacturer_by_id_query, get_manufacturers_query, update_manufacturer_query, } from "./manufacturers.queries";
 export async function server_get_manufacturers(options) {
-    const supabase = await newServerClient();
-    let query = supabase.from("manufacturers").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_manufacturers_query(await newServerClient(), options);
 }
 export async function server_get_manufacturer_by_id(manufacturer_id) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("manufacturers")
-        .select("*")
-        .eq("id", manufacturer_id)
-        .maybeSingle();
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
-    }
-    return IWebResponse.success(data).to_compatible();
+    return get_manufacturer_by_id_query(await newServerClient(), manufacturer_id);
 }
 export async function server_create_manufacturer(row) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("manufacturers")
-        .insert(row)
-        .select("*")
-        .single();
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
-    }
-    return IWebResponse.success(data).to_compatible();
+    return create_manufacturer_query(await newServerClient(), row);
 }
 export async function server_update_manufacturer(manufacturer_id, updates) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("manufacturers")
-        .update(updates)
-        .eq("id", manufacturer_id)
-        .select("*")
-        .single();
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
-    }
-    return IWebResponse.success(data).to_compatible();
+    return update_manufacturer_query(await newServerClient(), manufacturer_id, updates);
 }

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

@@ -0,0 +1,10 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { IManufacturer, ManufacturerInsert, ManufacturerUpdate } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+import { Database } from "../types/supabase";
+export declare function get_manufacturers_query(client: SupabaseClient<Database>, options?: {
+    include_inactive?: boolean;
+}): Promise<IWebResponseCompatible<IManufacturer[]>>;
+export declare function get_manufacturer_by_id_query(client: SupabaseClient<Database>, manufacturer_id: number): Promise<IWebResponseCompatible<IManufacturer | null>>;
+export declare function create_manufacturer_query(client: SupabaseClient<Database>, row: ManufacturerInsert): Promise<IWebResponseCompatible<IManufacturer | null>>;
+export declare function update_manufacturer_query(client: SupabaseClient<Database>, manufacturer_id: number, updates: ManufacturerUpdate): Promise<IWebResponseCompatible<IManufacturer | null>>;

package/dist/helpers/manufacturers.queries.js

@@ -0,0 +1,46 @@
+import { EnumWebResponse, IWebResponse, } from "../types/requests";
+export async function get_manufacturers_query(client, options) {
+    let query = client.from("manufacturers").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_manufacturer_by_id_query(client, manufacturer_id) {
+    const { data, error } = await client
+        .from("manufacturers")
+        .select("*")
+        .eq("id", manufacturer_id)
+        .maybeSingle();
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function create_manufacturer_query(client, row) {
+    const { data, error } = await client
+        .from("manufacturers")
+        .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_manufacturer_query(client, manufacturer_id, updates) {
+    const { data, error } = await client
+        .from("manufacturers")
+        .update(updates)
+        .eq("id", manufacturer_id)
+        .select("*")
+        .single();
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    return IWebResponse.success(data).to_compatible();
+}

package/dist/helpers/media_urls.d.ts

@@ -0,0 +1,13 @@
+import type { SupabaseClient } from "@supabase/supabase-js";
+import type { IArtifact, IArtifactWithMediaUrl } from "../types/db";
+import type { Database } from "../types/supabase";
+type EventWithStoragePath = {
+    file_path?: string | null;
+    media_url?: string | null;
+};
+export declare function createSignedUrlMap(client: SupabaseClient<Database>, paths: Iterable<string | null | undefined>): Promise<Map<string, string | null>>;
+export declare function addEventMediaUrls<T extends EventWithStoragePath>(client: SupabaseClient<Database>, events: T[]): Promise<Array<T & {
+    media_url: string | null;
+}>>;
+export declare function addArtifactMediaUrls(client: SupabaseClient<Database>, artifacts: IArtifact[]): Promise<IArtifactWithMediaUrl[]>;
+export {};