@adventurelabs/scout-core 1.5.5 → 2.0.1

package/dist/helpers/{invitations_internal.js → invitations.queries.js}

@@ -1,6 +1,6 @@
 import { IWebResponse } from "../types/requests";
-export async function createHerdInvitationWithClient(supabase, herd_id, email, herd_role_id, expires_at) {
-    const { data, error } = await supabase.rpc("create_herd_invitation", {
+export async function create_herd_invitation_query(client, herd_id, email, herd_role_id, expires_at) {
+    const { data, error } = await client.rpc("create_herd_invitation", {
         p_herd_id: herd_id,
         p_email: email,
         p_herd_role_id: herd_role_id,
@@ -11,25 +11,25 @@ export async function createHerdInvitationWithClient(supabase, herd_id, email, h
     }
     return IWebResponse.success(data).to_compatible();
 }
-export async function acceptHerdInvitationsWithClient(supabase, invitation_ids) {
+export async function accept_herd_invitations_for_current_user_query(client, invitation_ids) {
     if (invitation_ids.length === 0) {
         return IWebResponse.error("At least one invitation id is required").to_compatible();
     }
-    const { data, error } = await supabase.rpc("accept_herd_invitations_for_current_user", { p_invitation_ids: invitation_ids });
+    const { data, error } = await client.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 getHerdInvitationsForCurrentUserWithClient(supabase) {
-    const { data, error } = await supabase.rpc("get_herd_invitations_for_current_user");
+export async function get_herd_invitations_for_current_user_query(client) {
+    const { data, error } = await client.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 getHerdInvitationsByHerdWithClient(supabase, herd_id) {
-    const { data, error } = await supabase
+export async function get_herd_invitations_by_herd_query(client, herd_id) {
+    const { data, error } = await client
         .from("herd_invitations")
         .select("*")
         .eq("herd_id", herd_id)
@@ -39,21 +39,21 @@ export async function getHerdInvitationsByHerdWithClient(supabase, herd_id) {
     }
     return IWebResponse.success(data ?? []).to_compatible();
 }
-export async function rejectHerdInvitationsWithClient(supabase, invitation_ids) {
+export async function reject_herd_invitations_for_current_user_query(client, invitation_ids) {
     if (invitation_ids.length === 0) {
         return IWebResponse.error("At least one invitation id is required").to_compatible();
     }
-    const { data, error } = await supabase.rpc("reject_herd_invitations_for_current_user", { p_invitation_ids: invitation_ids });
+    const { data, error } = await client.rpc("reject_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 revokeHerdInvitationsWithClient(supabase, invitation_ids) {
+export async function revoke_herd_invitations_query(client, invitation_ids) {
     if (invitation_ids.length === 0) {
         return IWebResponse.error("At least one invitation id is required").to_compatible();
     }
-    const { data, error } = await supabase.rpc("revoke_herd_invitations", {
+    const { data, error } = await client.rpc("revoke_herd_invitations", {
         p_invitation_ids: invitation_ids,
     });
     if (error) {

package/dist/helpers/issuers.js

@@ -1,63 +1,17 @@
-"use server";
 import { newServerClient } from "../supabase/server";
-import { EnumWebResponse, IWebResponse, } from "../types/requests";
+import { create_issuer_query, get_issuer_by_id_query, get_issuers_by_localization_query, get_issuers_query, update_issuer_query, } from "./issuers.queries";
 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();
+    return get_issuers_query(await newServerClient());
 }
 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();
+    return get_issuer_by_id_query(await newServerClient(), issuer_id);
 }
 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();
+    return get_issuers_by_localization_query(await newServerClient(), localization_id);
 }
 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();
+    return create_issuer_query(await newServerClient(), row);
 }
 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();
+    return update_issuer_query(await newServerClient(), issuer_id, updates);
 }

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

@@ -0,0 +1,9 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { IIssuer, IssuerInsert, IssuerUpdate } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+import { Database } from "../types/supabase";
+export declare function get_issuers_query(client: SupabaseClient<Database>): Promise<IWebResponseCompatible<IIssuer[]>>;
+export declare function get_issuer_by_id_query(client: SupabaseClient<Database>, issuer_id: number): Promise<IWebResponseCompatible<IIssuer | null>>;
+export declare function get_issuers_by_localization_query(client: SupabaseClient<Database>, localization_id: number): Promise<IWebResponseCompatible<IIssuer[]>>;
+export declare function create_issuer_query(client: SupabaseClient<Database>, row: IssuerInsert): Promise<IWebResponseCompatible<IIssuer | null>>;
+export declare function update_issuer_query(client: SupabaseClient<Database>, issuer_id: number, updates: IssuerUpdate): Promise<IWebResponseCompatible<IIssuer | null>>;

package/dist/helpers/issuers.queries.js

@@ -0,0 +1,53 @@
+import { EnumWebResponse, IWebResponse, } from "../types/requests";
+export async function get_issuers_query(client) {
+    const { data, error } = await client.from("issuers").select("*").order("name");
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
+    }
+    return IWebResponse.success(data ?? []).to_compatible();
+}
+export async function get_issuer_by_id_query(client, issuer_id) {
+    const { data, error } = await client
+        .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 get_issuers_by_localization_query(client, localization_id) {
+    const { data, error } = await client
+        .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 create_issuer_query(client, row) {
+    const { data, error } = await client
+        .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 update_issuer_query(client, issuer_id, updates) {
+    const { data, error } = await client
+        .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.js

@@ -1,26 +1,8 @@
-"use server";
 import { newServerClient } from "../supabase/server";
-import { EnumWebResponse, IWebResponse, } from "../types/requests";
-import { get_layers_by_herd_ids_query } from "./herd_scoped.queries";
-// function that fetches the layers from our db given a herd id
+import { get_layers_by_herd_ids_query, get_layers_by_herd_query, } from "./layers.queries";
 export async function server_get_layers_by_herd(herd_id) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("layers")
-        .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_layers_by_herd_query(await newServerClient(), herd_id);
 }
-// Fetches layers for many herds in one query, grouped by herd_id.
 export async function server_get_layers_by_herd_ids(herd_ids) {
     return get_layers_by_herd_ids_query(await newServerClient(), herd_ids);
 }

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

@@ -2,4 +2,5 @@ import { SupabaseClient } from "@supabase/supabase-js";
 import { ILayer } from "../types/db";
 import { Database } from "../types/supabase";
 import { IWebResponseCompatible } from "../types/requests";
-export declare function get_layers_by_herd_ids_query(client: SupabaseClient<Database>, herd_ids: number[]): Promise<IWebResponseCompatible<Record<number, ILayer[]>>>;
+export { get_layers_by_herd_ids_query } from "./herd_scoped.queries";
+export declare function get_layers_by_herd_query(client: SupabaseClient<Database>, herd_id: number): Promise<IWebResponseCompatible<ILayer[]>>;

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,178 @@
+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<{
+    contact_type_id: number | null;
+    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;
+    notes: string | null;
+    phone: string | null;
+    radio_frequency: 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();
+}