@adventurelabs/scout-core 1.5.4 → 2.0.0

package/dist/helpers/media_urls.js

@@ -0,0 +1,21 @@
+import { collectArtifactStoragePaths, withArtifactMediaUrls, } from "./artifactMedia";
+import { generateSignedUrlsBatchWithClient } from "./storage_internal";
+import { isNonEmptyStorageFilePath } from "./storagePath";
+export async function createSignedUrlMap(client, paths) {
+    const uniquePaths = Array.from(new Set(Array.from(paths).filter(isNonEmptyStorageFilePath)));
+    const urls = await generateSignedUrlsBatchWithClient(client, uniquePaths);
+    return new Map(uniquePaths.map((path, index) => [path, urls[index]]));
+}
+export async function addEventMediaUrls(client, events) {
+    const urlMap = await createSignedUrlMap(client, events.map((event) => event.file_path));
+    return events.map((event) => ({
+        ...event,
+        media_url: isNonEmptyStorageFilePath(event.file_path)
+            ? urlMap.get(event.file_path) ?? event.media_url ?? null
+            : event.media_url ?? null,
+    }));
+}
+export async function addArtifactMediaUrls(client, artifacts) {
+    const urlMap = await createSignedUrlMap(client, collectArtifactStoragePaths(artifacts));
+    return artifacts.map((artifact) => withArtifactMediaUrls(artifact, urlMap));
+}

package/dist/helpers/models.js

@@ -1,95 +1,23 @@
-"use server";
 import { newServerClient } from "../supabase/server";
-import { EnumWebResponse, IWebResponse, } from "../types/requests";
-// function that fetches a single model by id; null if not found
+import { create_models_per_jobs_per_herd_query, delete_models_per_jobs_per_herd_by_ids_query, get_model_by_id_query, get_models_by_ids_query, get_models_per_jobs_per_herd_by_herd_query, get_models_query, update_models_per_jobs_per_herd_query, } from "./models.queries";
 export async function server_get_model_by_id(model_id) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("models")
-        .select("*")
-        .eq("id", model_id)
-        .maybeSingle();
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
-    }
-    return IWebResponse.success(data).to_compatible();
+    return get_model_by_id_query(await newServerClient(), model_id);
 }
-// function that fetches multiple models by id
 export async function server_get_models_by_ids(model_ids) {
-    if (model_ids.length === 0) {
-        return IWebResponse.success([]).to_compatible();
-    }
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("models")
-        .select("*")
-        .in("id", model_ids);
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
-    }
-    return IWebResponse.success(data ?? []).to_compatible();
+    return get_models_by_ids_query(await newServerClient(), model_ids);
 }
-// function that lists models, active only by default
 export async function server_get_models(options) {
-    const supabase = await newServerClient();
-    let query = supabase.from("models").select("*").order("name");
-    if (!options?.include_inactive) {
-        query = query.eq("is_active", true);
-    }
-    const { data, error } = await query;
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
-    }
-    return IWebResponse.success(data ?? []).to_compatible();
+    return get_models_query(await newServerClient(), options);
 }
-// function that fetches the model activations for a herd
 export async function server_get_models_per_jobs_per_herd_by_herd(herd_id) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("models_per_jobs_per_herd")
-        .select("*")
-        .eq("herd_id", herd_id);
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
-    }
-    return IWebResponse.success(data ?? []).to_compatible();
+    return get_models_per_jobs_per_herd_by_herd_query(await newServerClient(), herd_id);
 }
-// function that creates a model activation
 export async function server_create_models_per_jobs_per_herd(activation) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("models_per_jobs_per_herd")
-        .insert(activation)
-        .select("*")
-        .single();
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
-    }
-    return IWebResponse.success(data).to_compatible();
+    return create_models_per_jobs_per_herd_query(await newServerClient(), activation);
 }
-// function that updates a model activation
 export async function server_update_models_per_jobs_per_herd(id, updates) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("models_per_jobs_per_herd")
-        .update(updates)
-        .eq("id", id)
-        .select("*")
-        .single();
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
-    }
-    return IWebResponse.success(data).to_compatible();
+    return update_models_per_jobs_per_herd_query(await newServerClient(), id, updates);
 }
-// function that deletes model activations by ids
 export async function server_delete_models_per_jobs_per_herd_by_ids(ids) {
-    const supabase = await newServerClient();
-    const { error } = await supabase
-        .from("models_per_jobs_per_herd")
-        .delete()
-        .in("id", ids);
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: false };
-    }
-    return IWebResponse.success(true).to_compatible();
+    return delete_models_per_jobs_per_herd_by_ids_query(await newServerClient(), ids);
 }

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

@@ -0,0 +1,13 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { IModel, IModelsPerJobsPerHerd } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+import { Database } from "../types/supabase";
+export declare function get_model_by_id_query(client: SupabaseClient<Database>, model_id: number): Promise<IWebResponseCompatible<IModel | null>>;
+export declare function get_models_by_ids_query(client: SupabaseClient<Database>, model_ids: number[]): Promise<IWebResponseCompatible<IModel[]>>;
+export declare function get_models_query(client: SupabaseClient<Database>, options?: {
+    include_inactive?: boolean;
+}): Promise<IWebResponseCompatible<IModel[]>>;
+export declare function get_models_per_jobs_per_herd_by_herd_query(client: SupabaseClient<Database>, herd_id: number): Promise<IWebResponseCompatible<IModelsPerJobsPerHerd[]>>;
+export declare function create_models_per_jobs_per_herd_query(client: SupabaseClient<Database>, activation: Omit<IModelsPerJobsPerHerd, "id" | "inserted_at">): Promise<IWebResponseCompatible<IModelsPerJobsPerHerd>>;
+export declare function update_models_per_jobs_per_herd_query(client: SupabaseClient<Database>, id: number, updates: Partial<Omit<IModelsPerJobsPerHerd, "id" | "inserted_at">>): Promise<IWebResponseCompatible<IModelsPerJobsPerHerd>>;
+export declare function delete_models_per_jobs_per_herd_by_ids_query(client: SupabaseClient<Database>, ids: number[]): Promise<IWebResponseCompatible<boolean>>;

package/dist/helpers/models.queries.js

@@ -0,0 +1,79 @@
+import { EnumWebResponse, IWebResponse, } from "../types/requests";
+export async function get_model_by_id_query(client, model_id) {
+    const { data, error } = await client
+        .from("models")
+        .select("*")
+        .eq("id", model_id)
+        .maybeSingle();
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function get_models_by_ids_query(client, model_ids) {
+    if (model_ids.length === 0) {
+        return IWebResponse.success([]).to_compatible();
+    }
+    const { data, error } = await client
+        .from("models")
+        .select("*")
+        .in("id", model_ids);
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
+    }
+    return IWebResponse.success(data ?? []).to_compatible();
+}
+export async function get_models_query(client, options) {
+    let query = client.from("models").select("*").order("name");
+    if (!options?.include_inactive) {
+        query = query.eq("is_active", true);
+    }
+    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_models_per_jobs_per_herd_by_herd_query(client, herd_id) {
+    const { data, error } = await client
+        .from("models_per_jobs_per_herd")
+        .select("*")
+        .eq("herd_id", herd_id);
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
+    }
+    return IWebResponse.success(data ?? []).to_compatible();
+}
+export async function create_models_per_jobs_per_herd_query(client, activation) {
+    const { data, error } = await client
+        .from("models_per_jobs_per_herd")
+        .insert(activation)
+        .select("*")
+        .single();
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function update_models_per_jobs_per_herd_query(client, id, updates) {
+    const { data, error } = await client
+        .from("models_per_jobs_per_herd")
+        .update(updates)
+        .eq("id", id)
+        .select("*")
+        .single();
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function delete_models_per_jobs_per_herd_by_ids_query(client, ids) {
+    const { error } = await client
+        .from("models_per_jobs_per_herd")
+        .delete()
+        .in("id", ids);
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: false };
+    }
+    return IWebResponse.success(true).to_compatible();
+}

package/dist/helpers/observations_server.d.ts

@@ -0,0 +1,51 @@
+import { ObservationInsert, ObservationUpdate } from "../types/db";
+export declare function server_get_observations_for_session(session_id: number): Promise<import("../types").IWebResponseCompatible<{
+    action_complete: boolean;
+    action_required: string | null;
+    description: string;
+    id: number;
+    inserted_at: string;
+    session_id: number;
+    timestamp: string | null;
+    updated_at: string | null;
+}[]>>;
+export declare function server_get_observation_by_id(observation_id: number): Promise<import("../types").IWebResponseCompatible<{
+    action_complete: boolean;
+    action_required: string | null;
+    description: string;
+    id: number;
+    inserted_at: string;
+    session_id: number;
+    timestamp: string | null;
+    updated_at: string | null;
+} | null>>;
+export declare function server_create_observation(row: ObservationInsert): Promise<import("../types").IWebResponseCompatible<{
+    action_complete: boolean;
+    action_required: string | null;
+    description: string;
+    id: number;
+    inserted_at: string;
+    session_id: number;
+    timestamp: string | null;
+    updated_at: string | null;
+} | null>>;
+export declare function server_update_observation(observation_id: number, patch: ObservationUpdate): Promise<import("../types").IWebResponseCompatible<{
+    action_complete: boolean;
+    action_required: string | null;
+    description: string;
+    id: number;
+    inserted_at: string;
+    session_id: number;
+    timestamp: string | null;
+    updated_at: string | null;
+} | null>>;
+export declare function server_delete_observation(observation_id: number): Promise<import("../types").IWebResponseCompatible<{
+    action_complete: boolean;
+    action_required: string | null;
+    description: string;
+    id: number;
+    inserted_at: string;
+    session_id: number;
+    timestamp: string | null;
+    updated_at: string | null;
+} | null>>;

package/dist/helpers/observations_server.js

@@ -0,0 +1,22 @@
+import { newServerClient } from "../supabase/server";
+import { create_observation, delete_observation, get_observation_by_id, get_observations_for_session, update_observation, } from "./observations";
+export async function server_get_observations_for_session(session_id) {
+    const client = await newServerClient();
+    return get_observations_for_session(client, session_id);
+}
+export async function server_get_observation_by_id(observation_id) {
+    const client = await newServerClient();
+    return get_observation_by_id(client, observation_id);
+}
+export async function server_create_observation(row) {
+    const client = await newServerClient();
+    return create_observation(client, row);
+}
+export async function server_update_observation(observation_id, patch) {
+    const client = await newServerClient();
+    return update_observation(client, observation_id, patch);
+}
+export async function server_delete_observation(observation_id) {
+    const client = await newServerClient();
+    return delete_observation(client, observation_id);
+}

package/dist/helpers/operating_contexts.js

@@ -1,231 +1,116 @@
-"use server";
 import { newServerClient } from "../supabase/server";
-import { IWebResponse } from "../types/requests";
-function error(message) {
-    return IWebResponse.error(message).to_compatible();
-}
-function page_limit(options) {
-    const limit = options?.limit ?? 100;
-    return limit < 1 || limit > 500 ? null : limit;
-}
-async function authenticated_user_id(client) {
-    const { data, error: authError } = await client.auth.getUser();
-    return authError ? null : (data.user?.id ?? null);
-}
-function with_lifecycle_actor(updates, user_id) {
-    return updates.lifecycle
-        ? { ...updates, lifecycle_changed_by: user_id }
-        : updates;
-}
-function with_update_actor(updates, user_id) {
-    return { ...with_lifecycle_actor(updates, user_id), updated_by: user_id };
-}
-function update_error(updates) {
-    if (Object.keys(updates).length === 0)
-        return "no fields to update";
-    if (updates.lifecycle_reason !== undefined && updates.lifecycle === undefined) {
-        return "lifecycle_reason requires lifecycle";
-    }
-    return null;
-}
-async function list_by(table, column, value, options) {
-    const limit = page_limit(options);
-    if (limit == null)
-        return error("limit must be between 1 and 500");
-    const supabase = await newServerClient();
-    let query = supabase
-        .from(table)
-        .select("*")
-        .eq(column, value)
-        .order("id")
-        .limit(limit);
-    if (!options?.include_inactive)
-        query = query.eq("lifecycle", "active");
-    if (options?.after_id != null)
-        query = query.gt("id", options.after_id);
-    const { data, error: queryError } = await query;
-    return queryError
-        ? error(queryError.message)
-        : IWebResponse.success((data ?? [])).to_compatible();
-}
-async function insert_row(table, row) {
-    const supabase = await newServerClient();
-    const { data, error: queryError } = await supabase
-        .from(table)
-        .insert(row)
-        .select("*")
-        .single();
-    return queryError
-        ? error(queryError.message)
-        : IWebResponse.success(data).to_compatible();
-}
-async function insert_with_creator(table, row) {
-    const supabase = await newServerClient();
-    const user_id = await authenticated_user_id(supabase);
-    if (!user_id)
-        return error("authentication required");
-    const { data, error: queryError } = await supabase
-        .from(table)
-        .insert({ ...row, created_by: user_id })
-        .select("*")
-        .single();
-    return queryError
-        ? error(queryError.message)
-        : IWebResponse.success(data).to_compatible();
-}
-async function patch_row(table, id, updates, actor) {
-    const invalid = update_error(updates);
-    if (invalid)
-        return error(invalid);
-    const supabase = await newServerClient();
-    const user_id = await authenticated_user_id(supabase);
-    if (!user_id)
-        return error("authentication required");
-    const payload = actor === "update"
-        ? with_update_actor(updates, user_id)
-        : with_lifecycle_actor(updates, user_id);
-    const { data, error: queryError } = await supabase
-        .from(table)
-        .update(payload)
-        .eq("id", id)
-        .select("*")
-        .single();
-    return queryError
-        ? error(queryError.message)
-        : IWebResponse.success(data).to_compatible();
-}
+import * as queries from "./operating_contexts.queries";
 export async function server_get_document_conditions_by_localization(localization_id, options) {
-    return list_by("document_conditions", "localization_id", localization_id, options);
+    return queries.get_document_conditions_by_localization_query(await newServerClient(), localization_id, options);
 }
 export async function server_create_document_condition(row) {
-    return insert_row("document_conditions", row);
+    return queries.create_document_condition_query(await newServerClient(), row);
 }
 export async function server_update_document_condition(id, updates) {
-    return patch_row("document_conditions", id, updates, "lifecycle");
+    return queries.update_document_condition_query(await newServerClient(), id, updates);
 }
 export async function server_get_operating_context_types_by_localization(localization_id, options) {
-    return list_by("operating_context_types", "localization_id", localization_id, options);
+    return queries.get_operating_context_types_by_localization_query(await newServerClient(), localization_id, options);
 }
 export async function server_create_operating_context_type(row) {
-    return insert_row("operating_context_types", row);
+    return queries.create_operating_context_type_query(await newServerClient(), row);
 }
 export async function server_update_operating_context_type(id, updates) {
-    return patch_row("operating_context_types", id, updates, "lifecycle");
+    return queries.update_operating_context_type_query(await newServerClient(), id, updates);
 }
 export async function server_get_operating_context_roles_by_localization(localization_id, options) {
-    return list_by("operating_context_roles", "localization_id", localization_id, options);
+    return queries.get_operating_context_roles_by_localization_query(await newServerClient(), localization_id, options);
 }
 export async function server_create_operating_context_role(row) {
-    return insert_row("operating_context_roles", row);
+    return queries.create_operating_context_role_query(await newServerClient(), row);
 }
 export async function server_update_operating_context_role(id, updates) {
-    return patch_row("operating_context_roles", id, updates, "lifecycle");
+    return queries.update_operating_context_role_query(await newServerClient(), id, updates);
 }
 export async function server_get_operating_context_equipment_categories_by_localization(localization_id, options) {
-    return list_by("operating_context_equipment_categories", "localization_id", localization_id, options);
+    return queries.get_operating_context_equipment_categories_by_localization_query(await newServerClient(), localization_id, options);
 }
 export async function server_create_operating_context_equipment_category(row) {
-    return insert_row("operating_context_equipment_categories", row);
+    return queries.create_operating_context_equipment_category_query(await newServerClient(), row);
 }
 export async function server_update_operating_context_equipment_category(id, updates) {
-    return patch_row("operating_context_equipment_categories", id, updates, "lifecycle");
+    return queries.update_operating_context_equipment_category_query(await newServerClient(), id, updates);
 }
 export async function server_get_operating_context_equipment_items_by_category(equipment_category_id, options) {
-    return list_by("operating_context_equipment_items", "equipment_category_id", equipment_category_id, options);
+    return queries.get_operating_context_equipment_items_by_category_query(await newServerClient(), equipment_category_id, options);
 }
 export async function server_create_operating_context_equipment_item(row) {
-    return insert_row("operating_context_equipment_items", row);
+    return queries.create_operating_context_equipment_item_query(await newServerClient(), row);
 }
 export async function server_update_operating_context_equipment_item(id, updates) {
-    return patch_row("operating_context_equipment_items", id, updates, "lifecycle");
+    return queries.update_operating_context_equipment_item_query(await newServerClient(), id, updates);
 }
 export async function server_get_operating_contexts_by_herd(herd_id, options) {
-    return list_by("operating_contexts", "herd_id", herd_id, options);
+    return queries.get_operating_contexts_by_herd_query(await newServerClient(), herd_id, options);
 }
 export async function server_get_operating_context_by_id(id) {
-    const supabase = await newServerClient();
-    const { data, error: queryError } = await supabase
-        .from("operating_contexts")
-        .select("*")
-        .eq("id", id)
-        .maybeSingle();
-    return queryError
-        ? error(queryError.message)
-        : IWebResponse.success(data).to_compatible();
+    return queries.get_operating_context_by_id_query(await newServerClient(), id);
 }
 export async function server_create_operating_context(row) {
-    return insert_with_creator("operating_contexts", row);
+    return queries.create_operating_context_query(await newServerClient(), row);
 }
 export async function server_update_operating_context(id, updates) {
-    return patch_row("operating_contexts", id, updates, "update");
+    return queries.update_operating_context_query(await newServerClient(), id, updates);
 }
 export async function server_get_operating_context_payloads_by_operating_context(operating_context_id, options) {
-    return list_by("operating_context_payloads", "operating_context_id", operating_context_id, options);
+    return queries.get_operating_context_payloads_by_operating_context_query(await newServerClient(), operating_context_id, options);
 }
 export async function server_create_operating_context_payload(row) {
-    return insert_with_creator("operating_context_payloads", row);
+    return queries.create_operating_context_payload_query(await newServerClient(), row);
 }
 export async function server_update_operating_context_payload(id, updates) {
-    return patch_row("operating_context_payloads", id, updates, "update");
+    return queries.update_operating_context_payload_query(await newServerClient(), id, updates);
 }
 export async function server_get_operating_context_role_assignments_by_operating_context(operating_context_id, options) {
-    return list_by("operating_context_role_assignments", "operating_context_id", operating_context_id, options);
+    return queries.get_operating_context_role_assignments_by_operating_context_query(await newServerClient(), operating_context_id, options);
 }
 export async function server_create_operating_context_role_assignment(row) {
-    return insert_row("operating_context_role_assignments", row);
+    return queries.create_operating_context_role_assignment_query(await newServerClient(), row);
 }
 export async function server_update_operating_context_role_assignment(id, updates) {
-    return patch_row("operating_context_role_assignments", id, updates, "lifecycle");
+    return queries.update_operating_context_role_assignment_query(await newServerClient(), id, updates);
 }
 export async function server_get_operating_context_devices_by_operating_context(operating_context_id, options) {
-    return list_by("operating_contexts_devices", "operating_context_id", operating_context_id, options);
+    return queries.get_operating_context_devices_by_operating_context_query(await newServerClient(), operating_context_id, options);
 }
 export async function server_create_operating_context_device(row) {
-    return insert_row("operating_contexts_devices", row);
+    return queries.create_operating_context_device_query(await newServerClient(), row);
 }
 export async function server_update_operating_context_device(id, updates) {
-    return patch_row("operating_contexts_devices", id, updates, "lifecycle");
+    return queries.update_operating_context_device_query(await newServerClient(), id, updates);
 }
 export async function server_get_operating_context_equipment_requirements_by_operating_context(operating_context_id, options) {
-    return list_by("operating_context_equipment_requirements", "operating_context_id", operating_context_id, options);
+    return queries.get_operating_context_equipment_requirements_by_operating_context_query(await newServerClient(), operating_context_id, options);
 }
 export async function server_create_operating_context_equipment_requirement(row) {
-    return insert_row("operating_context_equipment_requirements", row);
+    return queries.create_operating_context_equipment_requirement_query(await newServerClient(), row);
 }
 export async function server_update_operating_context_equipment_requirement(id, updates) {
-    return patch_row("operating_context_equipment_requirements", id, updates, "lifecycle");
+    return queries.update_operating_context_equipment_requirement_query(await newServerClient(), id, updates);
 }
 export async function server_get_operating_context_regions_by_operating_context(operating_context_id, options) {
-    return list_by("operating_context_regions", "operating_context_id", operating_context_id, options);
+    return queries.get_operating_context_regions_by_operating_context_query(await newServerClient(), operating_context_id, options);
 }
 export async function server_create_operating_context_region(row) {
-    return insert_with_creator("operating_context_regions", row);
+    return queries.create_operating_context_region_query(await newServerClient(), row);
 }
 export async function server_update_operating_context_region(id, updates) {
-    return patch_row("operating_context_regions", id, updates, "update");
+    return queries.update_operating_context_region_query(await newServerClient(), id, updates);
 }
 export async function server_get_operating_context_risks_by_operating_context(operating_context_id, options) {
-    return list_by("operating_context_risks", "operating_context_id", operating_context_id, options);
+    return queries.get_operating_context_risks_by_operating_context_query(await newServerClient(), operating_context_id, options);
 }
 export async function server_create_operating_context_risk(row) {
-    return insert_with_creator("operating_context_risks", row);
+    return queries.create_operating_context_risk_query(await newServerClient(), row);
 }
 export async function server_update_operating_context_risk(id, updates) {
-    return patch_row("operating_context_risks", id, updates, "update");
+    return queries.update_operating_context_risk_query(await newServerClient(), id, updates);
 }
 export async function server_get_operating_context_weather_snapshots(operating_context_id, options) {
-    if (options?.limit != null &&
-        (options.limit < 1 || options.limit > 500)) {
-        return error("limit must be between 1 and 500");
-    }
-    const supabase = await newServerClient();
-    const { data, error: queryError } = await supabase.rpc("get_operating_context_weather_snapshots", {
-        operating_context_id_caller: operating_context_id,
-        limit_caller: options?.limit,
-        cursor_collected_at: options?.cursor?.collected_at,
-        cursor_id: options?.cursor?.id,
-    });
-    return queryError
-        ? error(queryError.message)
-        : IWebResponse.success(data ?? []).to_compatible();
+    return queries.get_operating_context_weather_snapshots_query(await newServerClient(), operating_context_id, options);
 }

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

@@ -0,0 +1,48 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { DocumentConditionCreateInput, DocumentConditionUpdateInput, IDocumentCondition, IOperatingContext, IOperatingContextDevice, IOperatingContextEquipmentCategory, IOperatingContextEquipmentItem, IOperatingContextEquipmentRequirement, IOperatingContextPayload, IOperatingContextRegion, IOperatingContextRisk, IOperatingContextRole, IOperatingContextRoleAssignment, IOperatingContextType, IOperatingContextWeatherSnapshot, OperatingContextCreateInput, OperatingContextDeviceCreateInput, OperatingContextDeviceUpdateInput, OperatingContextEquipmentCategoryCreateInput, OperatingContextEquipmentCategoryUpdateInput, OperatingContextEquipmentItemCreateInput, OperatingContextEquipmentItemUpdateInput, OperatingContextEquipmentRequirementCreateInput, OperatingContextEquipmentRequirementUpdateInput, OperatingContextListOptions, OperatingContextPayloadCreateInput, OperatingContextPayloadUpdateInput, OperatingContextRegionCreateInput, OperatingContextRegionUpdateInput, OperatingContextRiskCreateInput, OperatingContextRiskUpdateInput, OperatingContextRoleAssignmentCreateInput, OperatingContextRoleAssignmentUpdateInput, OperatingContextRoleCreateInput, OperatingContextRoleUpdateInput, OperatingContextTypeCreateInput, OperatingContextTypeUpdateInput, OperatingContextUpdateInput } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+import { Database } from "../types/supabase";
+export declare function get_document_conditions_by_localization_query(client: SupabaseClient<Database>, localization_id: number, options?: OperatingContextListOptions): Promise<IWebResponseCompatible<IDocumentCondition[]>>;
+export declare function create_document_condition_query(client: SupabaseClient<Database>, row: DocumentConditionCreateInput): Promise<IWebResponseCompatible<IDocumentCondition | null>>;
+export declare function update_document_condition_query(client: SupabaseClient<Database>, id: number, updates: DocumentConditionUpdateInput): Promise<IWebResponseCompatible<IDocumentCondition | null>>;
+export declare function get_operating_context_types_by_localization_query(client: SupabaseClient<Database>, localization_id: number, options?: OperatingContextListOptions): Promise<IWebResponseCompatible<IOperatingContextType[]>>;
+export declare function create_operating_context_type_query(client: SupabaseClient<Database>, row: OperatingContextTypeCreateInput): Promise<IWebResponseCompatible<IOperatingContextType | null>>;
+export declare function update_operating_context_type_query(client: SupabaseClient<Database>, id: number, updates: OperatingContextTypeUpdateInput): Promise<IWebResponseCompatible<IOperatingContextType | null>>;
+export declare function get_operating_context_roles_by_localization_query(client: SupabaseClient<Database>, localization_id: number, options?: OperatingContextListOptions): Promise<IWebResponseCompatible<IOperatingContextRole[]>>;
+export declare function create_operating_context_role_query(client: SupabaseClient<Database>, row: OperatingContextRoleCreateInput): Promise<IWebResponseCompatible<IOperatingContextRole | null>>;
+export declare function update_operating_context_role_query(client: SupabaseClient<Database>, id: number, updates: OperatingContextRoleUpdateInput): Promise<IWebResponseCompatible<IOperatingContextRole | null>>;
+export declare function get_operating_context_equipment_categories_by_localization_query(client: SupabaseClient<Database>, localization_id: number, options?: OperatingContextListOptions): Promise<IWebResponseCompatible<IOperatingContextEquipmentCategory[]>>;
+export declare function create_operating_context_equipment_category_query(client: SupabaseClient<Database>, row: OperatingContextEquipmentCategoryCreateInput): Promise<IWebResponseCompatible<IOperatingContextEquipmentCategory | null>>;
+export declare function update_operating_context_equipment_category_query(client: SupabaseClient<Database>, id: number, updates: OperatingContextEquipmentCategoryUpdateInput): Promise<IWebResponseCompatible<IOperatingContextEquipmentCategory | null>>;
+export declare function get_operating_context_equipment_items_by_category_query(client: SupabaseClient<Database>, equipment_category_id: number, options?: OperatingContextListOptions): Promise<IWebResponseCompatible<IOperatingContextEquipmentItem[]>>;
+export declare function create_operating_context_equipment_item_query(client: SupabaseClient<Database>, row: OperatingContextEquipmentItemCreateInput): Promise<IWebResponseCompatible<IOperatingContextEquipmentItem | null>>;
+export declare function update_operating_context_equipment_item_query(client: SupabaseClient<Database>, id: number, updates: OperatingContextEquipmentItemUpdateInput): Promise<IWebResponseCompatible<IOperatingContextEquipmentItem | null>>;
+export declare function get_operating_contexts_by_herd_query(client: SupabaseClient<Database>, herd_id: number, options?: OperatingContextListOptions): Promise<IWebResponseCompatible<IOperatingContext[]>>;
+export declare function get_operating_context_by_id_query(client: SupabaseClient<Database>, id: number): Promise<IWebResponseCompatible<IOperatingContext | null>>;
+export declare function create_operating_context_query(client: SupabaseClient<Database>, row: OperatingContextCreateInput): Promise<IWebResponseCompatible<IOperatingContext | null>>;
+export declare function update_operating_context_query(client: SupabaseClient<Database>, id: number, updates: OperatingContextUpdateInput): Promise<IWebResponseCompatible<IOperatingContext | null>>;
+export declare function get_operating_context_payloads_by_operating_context_query(client: SupabaseClient<Database>, operating_context_id: number, options?: OperatingContextListOptions): Promise<IWebResponseCompatible<IOperatingContextPayload[]>>;
+export declare function create_operating_context_payload_query(client: SupabaseClient<Database>, row: OperatingContextPayloadCreateInput): Promise<IWebResponseCompatible<IOperatingContextPayload | null>>;
+export declare function update_operating_context_payload_query(client: SupabaseClient<Database>, id: number, updates: OperatingContextPayloadUpdateInput): Promise<IWebResponseCompatible<IOperatingContextPayload | null>>;
+export declare function get_operating_context_role_assignments_by_operating_context_query(client: SupabaseClient<Database>, operating_context_id: number, options?: OperatingContextListOptions): Promise<IWebResponseCompatible<IOperatingContextRoleAssignment[]>>;
+export declare function create_operating_context_role_assignment_query(client: SupabaseClient<Database>, row: OperatingContextRoleAssignmentCreateInput): Promise<IWebResponseCompatible<IOperatingContextRoleAssignment | null>>;
+export declare function update_operating_context_role_assignment_query(client: SupabaseClient<Database>, id: number, updates: OperatingContextRoleAssignmentUpdateInput): Promise<IWebResponseCompatible<IOperatingContextRoleAssignment | null>>;
+export declare function get_operating_context_devices_by_operating_context_query(client: SupabaseClient<Database>, operating_context_id: number, options?: OperatingContextListOptions): Promise<IWebResponseCompatible<IOperatingContextDevice[]>>;
+export declare function create_operating_context_device_query(client: SupabaseClient<Database>, row: OperatingContextDeviceCreateInput): Promise<IWebResponseCompatible<IOperatingContextDevice | null>>;
+export declare function update_operating_context_device_query(client: SupabaseClient<Database>, id: number, updates: OperatingContextDeviceUpdateInput): Promise<IWebResponseCompatible<IOperatingContextDevice | null>>;
+export declare function get_operating_context_equipment_requirements_by_operating_context_query(client: SupabaseClient<Database>, operating_context_id: number, options?: OperatingContextListOptions): Promise<IWebResponseCompatible<IOperatingContextEquipmentRequirement[]>>;
+export declare function create_operating_context_equipment_requirement_query(client: SupabaseClient<Database>, row: OperatingContextEquipmentRequirementCreateInput): Promise<IWebResponseCompatible<IOperatingContextEquipmentRequirement | null>>;
+export declare function update_operating_context_equipment_requirement_query(client: SupabaseClient<Database>, id: number, updates: OperatingContextEquipmentRequirementUpdateInput): Promise<IWebResponseCompatible<IOperatingContextEquipmentRequirement | null>>;
+export declare function get_operating_context_regions_by_operating_context_query(client: SupabaseClient<Database>, operating_context_id: number, options?: OperatingContextListOptions): Promise<IWebResponseCompatible<IOperatingContextRegion[]>>;
+export declare function create_operating_context_region_query(client: SupabaseClient<Database>, row: OperatingContextRegionCreateInput): Promise<IWebResponseCompatible<IOperatingContextRegion | null>>;
+export declare function update_operating_context_region_query(client: SupabaseClient<Database>, id: number, updates: OperatingContextRegionUpdateInput): Promise<IWebResponseCompatible<IOperatingContextRegion | null>>;
+export declare function get_operating_context_risks_by_operating_context_query(client: SupabaseClient<Database>, operating_context_id: number, options?: OperatingContextListOptions): Promise<IWebResponseCompatible<IOperatingContextRisk[]>>;
+export declare function create_operating_context_risk_query(client: SupabaseClient<Database>, row: OperatingContextRiskCreateInput): Promise<IWebResponseCompatible<IOperatingContextRisk | null>>;
+export declare function update_operating_context_risk_query(client: SupabaseClient<Database>, id: number, updates: OperatingContextRiskUpdateInput): Promise<IWebResponseCompatible<IOperatingContextRisk | null>>;
+export declare function get_operating_context_weather_snapshots_query(client: SupabaseClient<Database>, operating_context_id: number, options?: {
+    limit?: number;
+    cursor?: {
+        collected_at: string;
+        id: number;
+    };
+}): Promise<IWebResponseCompatible<IOperatingContextWeatherSnapshot[]>>;