@adventurelabs/scout-core 1.4.43 → 1.4.44

package/dist/helpers/analysis_usage/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./jobs";
+export * from "./tasks";

package/dist/helpers/analysis_usage/index.js

@@ -0,0 +1,2 @@
+export * from "./jobs";
+export * from "./tasks";

package/dist/helpers/analysis_usage/jobs.d.ts

@@ -0,0 +1,10 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { Database } from "../../types/supabase";
+import { AnalysisWorkStatus, IAnalysisJob } from "../../types/db";
+import { IWebResponseCompatible } from "../../types/requests";
+export type GetAnalysisJobsOptions = {
+    limit?: number;
+    status?: AnalysisWorkStatus;
+};
+export declare function get_analysis_jobs(client: SupabaseClient<Database>, options?: GetAnalysisJobsOptions): Promise<IWebResponseCompatible<IAnalysisJob[]>>;
+export declare function get_analysis_job_by_id(client: SupabaseClient<Database>, job_id: number): Promise<IWebResponseCompatible<IAnalysisJob | null>>;

package/dist/helpers/analysis_usage/jobs.js

@@ -0,0 +1,31 @@
+import { IWebResponse } from "../../types/requests";
+export async function get_analysis_jobs(client, options) {
+    const limit = options?.limit ?? 100;
+    let query = client
+        .from("analysis_jobs")
+        .select("*")
+        .order("timestamp_requested", { ascending: false })
+        .limit(limit);
+    if (options?.status != null) {
+        query = query.eq("status", options.status);
+    }
+    const { data, error } = await query;
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    return IWebResponse.success(data ?? []).to_compatible();
+}
+export async function get_analysis_job_by_id(client, job_id) {
+    const { data, error } = await client
+        .from("analysis_jobs")
+        .select("*")
+        .eq("id", job_id)
+        .single();
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error("Analysis job not found").to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}

package/dist/helpers/analysis_usage/tasks.d.ts

@@ -0,0 +1,14 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { Database } from "../../types/supabase";
+import { AnalysisWorkStatus, IAnalysisTask } from "../../types/db";
+import { IWebResponseCompatible } from "../../types/requests";
+export type GetAnalysisTasksOptions = {
+    limit?: number;
+    job_id?: number;
+    status?: AnalysisWorkStatus;
+};
+export declare function get_analysis_tasks(client: SupabaseClient<Database>, options?: GetAnalysisTasksOptions): Promise<IWebResponseCompatible<IAnalysisTask[]>>;
+export declare function get_analysis_tasks_for_job(client: SupabaseClient<Database>, job_id: number, options?: {
+    limit?: number;
+}): Promise<IWebResponseCompatible<IAnalysisTask[]>>;
+export declare function get_analysis_task_by_id(client: SupabaseClient<Database>, task_id: number): Promise<IWebResponseCompatible<IAnalysisTask | null>>;

package/dist/helpers/analysis_usage/tasks.js

@@ -0,0 +1,40 @@
+import { IWebResponse } from "../../types/requests";
+export async function get_analysis_tasks(client, options) {
+    const limit = options?.limit ?? 500;
+    let query = client
+        .from("analysis_tasks")
+        .select("*")
+        .order("id", { ascending: false })
+        .limit(limit);
+    if (options?.job_id != null) {
+        query = query.eq("job_id", options.job_id);
+    }
+    if (options?.status != null) {
+        query = query.eq("status", options.status);
+    }
+    const { data, error } = await query;
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    return IWebResponse.success(data ?? []).to_compatible();
+}
+export async function get_analysis_tasks_for_job(client, job_id, options) {
+    return get_analysis_tasks(client, {
+        job_id,
+        limit: options?.limit ?? 500,
+    });
+}
+export async function get_analysis_task_by_id(client, task_id) {
+    const { data, error } = await client
+        .from("analysis_tasks")
+        .select("*")
+        .eq("id", task_id)
+        .single();
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error("Analysis task not found").to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}

package/dist/helpers/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./analysis_usage";
 export * from "./auth";
 export * from "./bounding_boxes";
 export * from "./chat";

package/dist/helpers/index.js

@@ -1,3 +1,4 @@
+export * from "./analysis_usage";
 export * from "./auth";
 export * from "./bounding_boxes";
 export * from "./chat";

package/dist/hooks/index.d.ts

@@ -8,5 +8,5 @@ export { useScoutRealtimeSessions } from "./useScoutRealtimeSessions";
 export { useScoutRealtimePlans } from "./useScoutRealtimePlans";
 export { useScoutRealtimePins } from "./useScoutRealtimePins";
 export { useScoutRealtimeParts } from "./useScoutRealtimeParts";
-export { useInfiniteSessionsByHerd, useInfiniteSessionsByDevice, useInfiniteEventsByHerd, useInfiniteEventsByDevice, useInfiniteArtifactsByHerd, useInfiniteArtifactsByDevice, useInfiniteFeedByHerd, useInfiniteFeedByDevice, useIntersectionObserver, type UseInfiniteScrollOptions, } from "./useInfiniteQuery";
+export { useInfiniteSessionsByHerd, useInfiniteSessionsByDevice, useInfiniteEventsByHerd, useInfiniteEventsByDevice, useInfiniteArtifactsByHerd, useInfiniteArtifactsByDevice, useInfiniteFeedByHerd, useInfiniteFeedByDevice, useInfiniteAnalysisJobs, useInfiniteAnalysisTasks, useIntersectionObserver, type UseInfiniteScrollOptions, type UseAnalysisJobsInfiniteOptions, type UseAnalysisTasksInfiniteOptions, } from "./useInfiniteQuery";
 export { useLoadingPerformance, useSessionSummariesByHerd, useHasSessionSummaries, } from "../store/hooks";

package/dist/hooks/index.js

@@ -9,6 +9,6 @@ export { useScoutRealtimePlans } from "./useScoutRealtimePlans";
 export { useScoutRealtimePins } from "./useScoutRealtimePins";
 export { useScoutRealtimeParts } from "./useScoutRealtimeParts";
 // RTK Query infinite scroll hooks
-export { useInfiniteSessionsByHerd, useInfiniteSessionsByDevice, useInfiniteEventsByHerd, useInfiniteEventsByDevice, useInfiniteArtifactsByHerd, useInfiniteArtifactsByDevice, useInfiniteFeedByHerd, useInfiniteFeedByDevice, useIntersectionObserver, } from "./useInfiniteQuery";
+export { useInfiniteSessionsByHerd, useInfiniteSessionsByDevice, useInfiniteEventsByHerd, useInfiniteEventsByDevice, useInfiniteArtifactsByHerd, useInfiniteArtifactsByDevice, useInfiniteFeedByHerd, useInfiniteFeedByDevice, useInfiniteAnalysisJobs, useInfiniteAnalysisTasks, useIntersectionObserver, } from "./useInfiniteQuery";
 // Session summaries and performance hooks
 export { useLoadingPerformance, useSessionSummariesByHerd, useHasSessionSummaries, } from "../store/hooks";

package/dist/hooks/useInfiniteQuery.d.ts

@@ -1,5 +1,5 @@
 import { SupabaseClient } from "@supabase/supabase-js";
-import { IArtifactWithMediaUrl, ISessionWithCoordinates, IEventAndTagsPrettyLocation, IFeedItem } from "../types/db";
+import { IArtifactWithMediaUrl, ISessionWithCoordinates, IEventAndTagsPrettyLocation, IFeedItem, IAnalysisJob, IAnalysisTask, AnalysisWorkStatus } from "../types/db";
 export interface UseInfiniteScrollOptions {
     limit?: number;
     enabled?: boolean;
@@ -30,5 +30,20 @@ export declare const useInfiniteArtifactsByDevice: (deviceId: number, options: U
 /** useInfiniteFeedByHerd: logic matches useInfiniteFeedByHerdDummy verbatim; only the fetch is via API (RTK Query) instead of supabase.rpc. */
 export declare const useInfiniteFeedByHerd: (herdId: number, options: UseInfiniteScrollOptions) => InfiniteScrollData<IFeedItem>;
 export declare const useInfiniteFeedByDevice: (deviceId: number, options: UseInfiniteScrollOptions) => InfiniteScrollData<IFeedItem>;
+export interface UseAnalysisJobsInfiniteOptions {
+    limit?: number;
+    enabled?: boolean;
+    supabase: SupabaseClient;
+    status?: AnalysisWorkStatus | null;
+}
+export declare const useInfiniteAnalysisJobs: (options: UseAnalysisJobsInfiniteOptions) => InfiniteScrollData<IAnalysisJob>;
+export interface UseAnalysisTasksInfiniteOptions {
+    limit?: number;
+    enabled?: boolean;
+    supabase: SupabaseClient;
+    job_id?: number | null;
+    status?: AnalysisWorkStatus | null;
+}
+export declare const useInfiniteAnalysisTasks: (options: UseAnalysisTasksInfiniteOptions) => InfiniteScrollData<IAnalysisTask>;
 export declare const useIntersectionObserver: (callback: () => void, options?: IntersectionObserverInit) => import("react").Dispatch<import("react").SetStateAction<Element | null>>;
 export {};

package/dist/hooks/useInfiniteQuery.js

@@ -1,5 +1,5 @@
 import { useState, useCallback, useMemo, useEffect, useRef } from "react";
-import { useGetSessionsInfiniteByHerdQuery, useGetSessionsInfiniteByDeviceQuery, useGetEventsInfiniteByHerdQuery, useGetEventsInfiniteByDeviceQuery, useGetArtifactsInfiniteByHerdQuery, useGetArtifactsInfiniteByDeviceQuery, useGetFeedInfiniteByHerdQuery, useGetFeedInfiniteByDeviceQuery, } from "../store/api";
+import { useGetSessionsInfiniteByHerdQuery, useGetSessionsInfiniteByDeviceQuery, useGetEventsInfiniteByHerdQuery, useGetEventsInfiniteByDeviceQuery, useGetArtifactsInfiniteByHerdQuery, useGetArtifactsInfiniteByDeviceQuery, useGetFeedInfiniteByHerdQuery, useGetFeedInfiniteByDeviceQuery, useGetAnalysisJobsInfiniteQuery, useGetAnalysisTasksInfiniteQuery, } from "../store/api";
 function useInfiniteFiltersKey(options) {
     return useMemo(() => JSON.stringify({
         rangeStart: options.rangeStart ?? null,
@@ -814,6 +814,144 @@ export const useInfiniteFeedByDevice = (deviceId, options) => {
         error: currentQuery.error,
     };
 };
+function useAnalysisJobsInfiniteFiltersKey(options) {
+    return useMemo(() => JSON.stringify({ status: options.status ?? null }), [options.status]);
+}
+export const useInfiniteAnalysisJobs = (options) => {
+    const [pages, setPages] = useState([]);
+    const [currentCursor, setCurrentCursor] = useState(null);
+    const infiniteFiltersKey = useAnalysisJobsInfiniteFiltersKey(options);
+    const prevInfiniteFiltersKeyRef = useRef(null);
+    const currentQuery = useGetAnalysisJobsInfiniteQuery({
+        limit: options.limit || 20,
+        cursor: currentCursor,
+        supabase: options.supabase,
+        status: options.status ?? null,
+    }, {
+        skip: !options.enabled,
+    });
+    useEffect(() => {
+        if (prevInfiniteFiltersKeyRef.current === null) {
+            prevInfiniteFiltersKeyRef.current = infiniteFiltersKey;
+            return;
+        }
+        if (prevInfiniteFiltersKeyRef.current !== infiniteFiltersKey) {
+            prevInfiniteFiltersKeyRef.current = infiniteFiltersKey;
+            setPages([]);
+            setCurrentCursor(null);
+        }
+    }, [infiniteFiltersKey]);
+    useEffect(() => {
+        if (currentQuery.data && !currentQuery.isLoading) {
+            setPages((prev) => {
+                const existingPage = prev.find((p) => (p.cursor === null && currentCursor === null) ||
+                    (p.cursor != null &&
+                        currentCursor != null &&
+                        p.cursor.id === currentCursor.id));
+                if (!existingPage) {
+                    return [
+                        ...prev,
+                        { cursor: currentCursor, data: currentQuery.data.jobs },
+                    ];
+                }
+                return prev;
+            });
+        }
+    }, [currentQuery.data, currentQuery.isLoading, currentCursor]);
+    const loadMore = useCallback(() => {
+        if (currentQuery.data?.hasMore &&
+            currentQuery.data.nextCursor &&
+            !currentQuery.isLoading) {
+            setCurrentCursor(currentQuery.data.nextCursor);
+        }
+    }, [currentQuery.data, currentQuery.isLoading]);
+    const refetch = useCallback(() => {
+        setPages([]);
+        setCurrentCursor(null);
+        currentQuery.refetch();
+    }, [currentQuery]);
+    const allItems = useMemo(() => pages.flatMap((page) => page.data), [pages]);
+    return {
+        items: allItems,
+        isLoading: currentQuery.isLoading && pages.length === 0,
+        isLoadingMore: currentQuery.isLoading && pages.length > 0,
+        hasMore: currentQuery.data?.hasMore || false,
+        loadMore,
+        refetch,
+        error: currentQuery.error,
+    };
+};
+function useAnalysisTasksInfiniteFiltersKey(options) {
+    return useMemo(() => JSON.stringify({
+        job_id: options.job_id ?? null,
+        status: options.status ?? null,
+    }), [options.job_id, options.status]);
+}
+export const useInfiniteAnalysisTasks = (options) => {
+    const [pages, setPages] = useState([]);
+    const [currentCursor, setCurrentCursor] = useState(null);
+    const infiniteFiltersKey = useAnalysisTasksInfiniteFiltersKey(options);
+    const prevInfiniteFiltersKeyRef = useRef(null);
+    const currentQuery = useGetAnalysisTasksInfiniteQuery({
+        limit: options.limit || 20,
+        cursor: currentCursor,
+        supabase: options.supabase,
+        job_id: options.job_id ?? null,
+        status: options.status ?? null,
+    }, {
+        skip: !options.enabled,
+    });
+    useEffect(() => {
+        if (prevInfiniteFiltersKeyRef.current === null) {
+            prevInfiniteFiltersKeyRef.current = infiniteFiltersKey;
+            return;
+        }
+        if (prevInfiniteFiltersKeyRef.current !== infiniteFiltersKey) {
+            prevInfiniteFiltersKeyRef.current = infiniteFiltersKey;
+            setPages([]);
+            setCurrentCursor(null);
+        }
+    }, [infiniteFiltersKey]);
+    useEffect(() => {
+        if (currentQuery.data && !currentQuery.isLoading) {
+            setPages((prev) => {
+                const existingPage = prev.find((p) => (p.cursor === null && currentCursor === null) ||
+                    (p.cursor != null &&
+                        currentCursor != null &&
+                        p.cursor.id === currentCursor.id));
+                if (!existingPage) {
+                    return [
+                        ...prev,
+                        { cursor: currentCursor, data: currentQuery.data.tasks },
+                    ];
+                }
+                return prev;
+            });
+        }
+    }, [currentQuery.data, currentQuery.isLoading, currentCursor]);
+    const loadMore = useCallback(() => {
+        if (currentQuery.data?.hasMore &&
+            currentQuery.data.nextCursor &&
+            !currentQuery.isLoading) {
+            setCurrentCursor(currentQuery.data.nextCursor);
+        }
+    }, [currentQuery.data, currentQuery.isLoading]);
+    const refetch = useCallback(() => {
+        setPages([]);
+        setCurrentCursor(null);
+        currentQuery.refetch();
+    }, [currentQuery]);
+    const allItems = useMemo(() => pages.flatMap((page) => page.data), [pages]);
+    return {
+        items: allItems,
+        isLoading: currentQuery.isLoading && pages.length === 0,
+        isLoadingMore: currentQuery.isLoading && pages.length > 0,
+        hasMore: currentQuery.data?.hasMore || false,
+        loadMore,
+        refetch,
+        error: currentQuery.error,
+    };
+};
 // =====================================================
 // INTERSECTION OBSERVER HOOK FOR AUTO-LOADING
 // =====================================================

package/dist/index.d.ts

@@ -10,6 +10,7 @@ export * from "./types/supabase";
 export * from "./types/bounding_boxes";
 export * from "./types/events";
 export * from "./types/connectivity";
+export * from "./helpers/analysis_usage";
 export * from "./helpers/artifacts";
 export * from "./helpers/auth";
 export * from "./helpers/bounding_boxes";
@@ -63,5 +64,5 @@ export * from "./supabase/middleware";
 export * from "./supabase/server";
 export * from "./api_keys/actions";
 export type { HerdModule, IHerdModule } from "./types/herd_module";
-export type { IDevice, IEvent, IUser, IHerd, IHerdPrettyLocation, IEventWithTags, IZoneWithActions, IUserAndRole, IApiKeyScout, ILayer, IHeartbeat, IProvider, IConnectivity, ISession, ISessionWithCoordinates, IConnectivityWithCoordinates, IObservation, ObservationInsert, ObservationUpdate, } from "./types/db";
+export type { IDevice, IEvent, IUser, IHerd, IHerdPrettyLocation, IEventWithTags, IZoneWithActions, IUserAndRole, IApiKeyScout, ILayer, IHeartbeat, IProvider, IConnectivity, ISession, ISessionWithCoordinates, IConnectivityWithCoordinates, IObservation, ObservationInsert, ObservationUpdate, IAnalysisJob, IAnalysisTask, AnalysisWorkStatus, } from "./types/db";
 export { EnumSessionsVisibility } from "./types/events";

package/dist/index.js

@@ -13,6 +13,7 @@ export * from "./types/bounding_boxes";
 export * from "./types/events";
 export * from "./types/connectivity";
 // Helpers
+export * from "./helpers/analysis_usage";
 export * from "./helpers/artifacts";
 export * from "./helpers/auth";
 export * from "./helpers/bounding_boxes";

package/dist/providers/ScoutRefreshProvider.d.ts

@@ -47,6 +47,117 @@ export declare function useSupabase(): SupabaseClient<Database, "public", "publi
                 referencedColumns: ["id"];
             }];
         };
+        analysis_jobs: {
+            Row: {
+                id: number;
+                inserted_at: string;
+                status: Database["public"]["Enums"]["analysis_work_status"];
+                timestamp_finished: string | null;
+                timestamp_requested: string;
+                timestamp_started: string | null;
+            };
+            Insert: {
+                id?: number;
+                inserted_at?: string;
+                status?: Database["public"]["Enums"]["analysis_work_status"];
+                timestamp_finished?: string | null;
+                timestamp_requested?: string;
+                timestamp_started?: string | null;
+            };
+            Update: {
+                id?: number;
+                inserted_at?: string;
+                status?: Database["public"]["Enums"]["analysis_work_status"];
+                timestamp_finished?: string | null;
+                timestamp_requested?: string;
+                timestamp_started?: string | null;
+            };
+            Relationships: [];
+        };
+        analysis_tasks: {
+            Row: {
+                artifact_id: number | null;
+                cpu_core_seconds: number | null;
+                cpu_memory_avg: number | null;
+                event_id: number | null;
+                execution_environment: string;
+                frames_processed: number | null;
+                gpu_memory_peak: number | null;
+                gpu_seconds: number | null;
+                id: number;
+                job_id: number;
+                model: string | null;
+                status: Database["public"]["Enums"]["analysis_work_status"];
+                task_type: string;
+                time_finished: string | null;
+                time_started: string | null;
+            };
+            Insert: {
+                artifact_id?: number | null;
+                cpu_core_seconds?: number | null;
+                cpu_memory_avg?: number | null;
+                event_id?: number | null;
+                execution_environment: string;
+                frames_processed?: number | null;
+                gpu_memory_peak?: number | null;
+                gpu_seconds?: number | null;
+                id?: number;
+                job_id: number;
+                model?: string | null;
+                status?: Database["public"]["Enums"]["analysis_work_status"];
+                task_type: string;
+                time_finished?: string | null;
+                time_started?: string | null;
+            };
+            Update: {
+                artifact_id?: number | null;
+                cpu_core_seconds?: number | null;
+                cpu_memory_avg?: number | null;
+                event_id?: number | null;
+                execution_environment?: string;
+                frames_processed?: number | null;
+                gpu_memory_peak?: number | null;
+                gpu_seconds?: number | null;
+                id?: number;
+                job_id?: number;
+                model?: string | null;
+                status?: Database["public"]["Enums"]["analysis_work_status"];
+                task_type?: string;
+                time_finished?: string | null;
+                time_started?: string | null;
+            };
+            Relationships: [{
+                foreignKeyName: "analysis_tasks_artifact_id_fkey";
+                columns: ["artifact_id"];
+                isOneToOne: false;
+                referencedRelation: "artifacts";
+                referencedColumns: ["id"];
+            }, {
+                foreignKeyName: "analysis_tasks_event_id_fkey";
+                columns: ["event_id"];
+                isOneToOne: false;
+                referencedRelation: "events";
+                referencedColumns: ["id"];
+            }, {
+                foreignKeyName: "analysis_tasks_event_id_fkey";
+                columns: ["event_id"];
+                isOneToOne: false;
+                referencedRelation: "events_with_tags";
+                referencedColumns: ["id"];
+            }, {
+                foreignKeyName: "analysis_tasks_event_id_fkey";
+                columns: ["event_id"];
+                isOneToOne: false;
+                referencedRelation: "events_with_tags_by_session";
+                referencedColumns: ["id"];
+            }, {
+                foreignKeyName: "analysis_tasks_job_id_fkey";
+                columns: ["job_id"];
+                isOneToOne: false;
+                referencedRelation: "analysis_jobs";
+                referencedColumns: ["id"];
+            }];
+        };
         artifacts: {
             Row: {
                 created_at: string;
@@ -905,6 +1016,27 @@ export declare function useSupabase(): SupabaseClient<Database, "public", "publi
                 referencedColumns: ["id"];
             }];
         };
+        platform_superadmins: {
+            Row: {
+                inserted_at: string;
+                user_id: string;
+            };
+            Insert: {
+                inserted_at?: string;
+                user_id: string;
+            };
+            Update: {
+                inserted_at?: string;
+                user_id?: string;
+            };
+            Relationships: [{
+                foreignKeyName: "platform_superadmins_user_id_fkey";
+                columns: ["user_id"];
+                isOneToOne: true;
+                referencedRelation: "users";
+                referencedColumns: ["id"];
+            }];
+        };
         providers: {
             Row: {
                 created_at: string;
@@ -2480,6 +2612,7 @@ export declare function useSupabase(): SupabaseClient<Database, "public", "publi
         };
     };
     Enums: {
+        analysis_work_status: "waiting" | "cancelled" | "processing" | "failed" | "success";
         app_permission: "herds.delete" | "events.delete";
         component_status: "active" | "inactive";
         device_type: "trail_camera" | "drone_fixed_wing" | "drone_quad" | "gps_tracker" | "sentry_tower" | "smart_buoy" | "radio_mesh_base_station" | "radio_mesh_repeater" | "unknown" | "gps_tracker_vehicle" | "gps_tracker_person" | "radio_mesh_base_station_gateway";