@adventurelabs/scout-core 1.4.48 → 1.4.50

package/dist/helpers/auth.d.ts

@@ -1 +1,4 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { Database } from "../types/supabase";
 export declare function isEmailValidForLogin(email: string, approved_domains?: string[]): boolean;
+export declare function isCurrentUserPlatformSuperadmin(client: SupabaseClient<Database>): Promise<boolean>;

package/dist/helpers/auth.js

@@ -6,3 +6,11 @@ export function isEmailValidForLogin(email, approved_domains = APPROVED_DOMAINS)
 function isEmailFromApprovedDomain(email, approved_domains = APPROVED_DOMAINS) {
     return approved_domains.filter((domain) => email.endsWith(domain)).length > 0;
 }
+export async function isCurrentUserPlatformSuperadmin(client) {
+    const { data, error } = await client.rpc("is_platform_superadmin_current_user");
+    if (error) {
+        console.warn("[scout-core auth] Failed to check platform superadmin status:", error.message);
+        return false;
+    }
+    return data === true;
+}

package/dist/hooks/index.d.ts

@@ -8,5 +8,7 @@ export { useScoutRealtimeSessions } from "./useScoutRealtimeSessions";
 export { useScoutRealtimePlans } from "./useScoutRealtimePlans";
 export { useScoutRealtimePins } from "./useScoutRealtimePins";
 export { useScoutRealtimeParts } from "./useScoutRealtimeParts";
+export { useScoutRealtimeAnalysisJobs } from "./useScoutRealtimeAnalysisJobs";
+export { useScoutRealtimeAnalysisTasks } from "./useScoutRealtimeAnalysisTasks";
 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

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

package/dist/hooks/useScoutRealtimeAnalysisJobs.d.ts

@@ -0,0 +1,5 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { Database } from "../types/supabase";
+import { IAnalysisJob } from "../types/db";
+import { RealtimeData } from "../types/realtime";
+export declare function useScoutRealtimeAnalysisJobs(scoutSupabase: SupabaseClient<Database>): [RealtimeData<IAnalysisJob> | null, () => void];

package/dist/hooks/useScoutRealtimeAnalysisJobs.js

@@ -0,0 +1,61 @@
+"use client";
+import { useEffect, useRef, useCallback, useState } from "react";
+import { EnumRealtimeOperation } from "../types/realtime";
+export function useScoutRealtimeAnalysisJobs(scoutSupabase) {
+    const channels = useRef([]);
+    const [latestJobUpdate, setLatestJobUpdate] = useState(null);
+    const handleAnalysisJobBroadcast = useCallback((payload) => {
+        const { payload: data } = payload;
+        const jobData = data.record || data.old_record;
+        if (!jobData) {
+            return;
+        }
+        let operation;
+        switch (data.operation) {
+            case "INSERT":
+                operation = EnumRealtimeOperation.INSERT;
+                break;
+            case "UPDATE":
+                operation = EnumRealtimeOperation.UPDATE;
+                break;
+            case "DELETE":
+                operation = EnumRealtimeOperation.DELETE;
+                break;
+            default:
+                return;
+        }
+        console.log(`[scout-core realtime] ANALYSIS_JOB ${data.operation} received for job ${jobData.id}:`, JSON.stringify(jobData));
+        const realtimeData = {
+            data: jobData,
+            operation,
+        };
+        setLatestJobUpdate(realtimeData);
+    }, []);
+    const clearLatestUpdate = useCallback(() => {
+        setLatestJobUpdate(null);
+    }, []);
+    useEffect(() => {
+        if (!scoutSupabase)
+            return;
+        channels.current.forEach((channel) => scoutSupabase.removeChannel(channel));
+        channels.current = [];
+        clearLatestUpdate();
+        const channel = scoutSupabase
+            .channel("analysis_jobs_changes", { config: { private: true } })
+            .on("broadcast", { event: "*" }, handleAnalysisJobBroadcast)
+            .subscribe((status) => {
+            if (status === "SUBSCRIBED") {
+                console.log("[ANALYSIS_JOBS] ✅ Connected to analysis jobs broadcasts");
+            }
+            else if (status === "CHANNEL_ERROR") {
+                console.warn("[ANALYSIS_JOBS] 🟡 Failed to connect to analysis jobs broadcasts");
+            }
+        });
+        channels.current.push(channel);
+        return () => {
+            channels.current.forEach((ch) => scoutSupabase.removeChannel(ch));
+            channels.current = [];
+        };
+    }, [scoutSupabase, handleAnalysisJobBroadcast, clearLatestUpdate]);
+    return [latestJobUpdate, clearLatestUpdate];
+}

package/dist/hooks/useScoutRealtimeAnalysisTasks.d.ts

@@ -0,0 +1,5 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { Database } from "../types/supabase";
+import { IAnalysisTask } from "../types/db";
+import { RealtimeData } from "../types/realtime";
+export declare function useScoutRealtimeAnalysisTasks(scoutSupabase: SupabaseClient<Database>): [RealtimeData<IAnalysisTask> | null, () => void];

package/dist/hooks/useScoutRealtimeAnalysisTasks.js

@@ -0,0 +1,61 @@
+"use client";
+import { useEffect, useRef, useCallback, useState } from "react";
+import { EnumRealtimeOperation } from "../types/realtime";
+export function useScoutRealtimeAnalysisTasks(scoutSupabase) {
+    const channels = useRef([]);
+    const [latestTaskUpdate, setLatestTaskUpdate] = useState(null);
+    const handleAnalysisTaskBroadcast = useCallback((payload) => {
+        const { payload: data } = payload;
+        const taskData = data.record || data.old_record;
+        if (!taskData) {
+            return;
+        }
+        let operation;
+        switch (data.operation) {
+            case "INSERT":
+                operation = EnumRealtimeOperation.INSERT;
+                break;
+            case "UPDATE":
+                operation = EnumRealtimeOperation.UPDATE;
+                break;
+            case "DELETE":
+                operation = EnumRealtimeOperation.DELETE;
+                break;
+            default:
+                return;
+        }
+        console.log(`[scout-core realtime] ANALYSIS_TASK ${data.operation} received for task ${taskData.id} (job ${taskData.job_id}):`, JSON.stringify(taskData));
+        const realtimeData = {
+            data: taskData,
+            operation,
+        };
+        setLatestTaskUpdate(realtimeData);
+    }, []);
+    const clearLatestUpdate = useCallback(() => {
+        setLatestTaskUpdate(null);
+    }, []);
+    useEffect(() => {
+        if (!scoutSupabase)
+            return;
+        channels.current.forEach((channel) => scoutSupabase.removeChannel(channel));
+        channels.current = [];
+        clearLatestUpdate();
+        const channel = scoutSupabase
+            .channel("analysis_tasks_changes", { config: { private: true } })
+            .on("broadcast", { event: "*" }, handleAnalysisTaskBroadcast)
+            .subscribe((status) => {
+            if (status === "SUBSCRIBED") {
+                console.log("[ANALYSIS_TASKS] ✅ Connected to analysis tasks broadcasts");
+            }
+            else if (status === "CHANNEL_ERROR") {
+                console.warn("[ANALYSIS_TASKS] 🟡 Failed to connect to analysis tasks broadcasts");
+            }
+        });
+        channels.current.push(channel);
+        return () => {
+            channels.current.forEach((ch) => scoutSupabase.removeChannel(ch));
+            channels.current = [];
+        };
+    }, [scoutSupabase, handleAnalysisTaskBroadcast, clearLatestUpdate]);
+    return [latestTaskUpdate, clearLatestUpdate];
+}

package/dist/hooks/useScoutRefresh.js

@@ -117,38 +117,42 @@ export function useScoutRefresh(options = {}) {
                                 // Background fetch fresh data without blocking
                                 (async () => {
                                     try {
-                                        const backgroundStartTime = Date.now();
-                                        const [backgroundHerdModulesResult, backgroundUserResult] = await Promise.all([
-                                            (async () => {
-                                                const start = Date.now();
-                                                const result = await server_load_herd_modules();
-                                                const totalDuration = Date.now() - start;
-                                                const serverDuration = result.server_processing_time_ms || totalDuration;
-                                                const clientOverhead = totalDuration - serverDuration;
-                                                console.log(`[useScoutRefresh] Background API timing breakdown:`);
-                                                console.log(`  - Server processing: ${serverDuration}ms`);
-                                                console.log(`  - Client overhead: ${clientOverhead}ms`);
-                                                console.log(`  - Total request: ${totalDuration}ms`);
-                                                timingRefs.current.herdModulesDuration = serverDuration;
-                                                dispatch(setHerdModulesApiServerProcessingDuration(serverDuration));
-                                                dispatch(setHerdModulesApiTotalRequestDuration(totalDuration));
-                                                return result;
-                                            })(),
-                                            (async () => {
-                                                const start = Date.now();
-                                                const { data } = await supabase.auth.getUser();
-                                                const duration = Date.now() - start;
-                                                timingRefs.current.userApiDuration = duration;
-                                                dispatch(setUserApiDuration(duration));
-                                                return { data: data.user, status: "success" };
-                                            })(),
-                                        ]);
-                                        const backgroundDuration = Date.now() - backgroundStartTime;
+                                        const userPromise = (async () => {
+                                            const start = Date.now();
+                                            const { data } = await supabase.auth.getUser();
+                                            const duration = Date.now() - start;
+                                            timingRefs.current.userApiDuration = duration;
+                                            dispatch(setUserApiDuration(duration));
+                                            if (data.user) {
+                                                dispatch(setUser(data.user));
+                                            }
+                                            return data.user ?? null;
+                                        })();
+                                        let backgroundHerdModulesResult;
+                                        try {
+                                            const start = Date.now();
+                                            const result = await server_load_herd_modules();
+                                            const totalDuration = Date.now() - start;
+                                            const serverDuration = result.server_processing_time_ms || totalDuration;
+                                            const clientOverhead = totalDuration - serverDuration;
+                                            console.log(`[useScoutRefresh] Background API timing breakdown:`);
+                                            console.log(`  - Server processing: ${serverDuration}ms`);
+                                            console.log(`  - Client overhead: ${clientOverhead}ms`);
+                                            console.log(`  - Total request: ${totalDuration}ms`);
+                                            timingRefs.current.herdModulesDuration = serverDuration;
+                                            dispatch(setHerdModulesApiServerProcessingDuration(serverDuration));
+                                            dispatch(setHerdModulesApiTotalRequestDuration(totalDuration));
+                                            backgroundHerdModulesResult = result;
+                                        }
+                                        catch (e) {
+                                            await userPromise.catch(() => { });
+                                            throw e;
+                                        }
+                                        const backgroundUserResult = await userPromise;
                                         // Validate background responses
                                         if (backgroundHerdModulesResult.data &&
                                             Array.isArray(backgroundHerdModulesResult.data) &&
-                                            backgroundUserResult &&
-                                            backgroundUserResult.data) {
+                                            backgroundUserResult) {
                                             // Update cache with fresh data
                                             try {
                                                 await scoutCache.setHerdModules(backgroundHerdModulesResult.data, cacheTtlMs);
@@ -164,10 +168,6 @@ export function useScoutRefresh(options = {}) {
                                             // Update store with fresh data from background request
                                             console.log(`[useScoutRefresh] Updating store with background herd modules`);
                                             dispatch(setHerdModules(backgroundHerdModulesResult.data));
-                                            if (backgroundUserResult && backgroundUserResult.data) {
-                                                console.log(`[useScoutRefresh] Updating store with background user data`);
-                                                dispatch(setUser(backgroundUserResult.data));
-                                            }
                                             // Update data source to DATABASE
                                             dispatch(setDataSource(EnumDataSource.DATABASE));
                                             dispatch(setDataSourceInfo({
@@ -226,35 +226,41 @@ export function useScoutRefresh(options = {}) {
                 lastQueryAtRef.current = Date.now();
                 return;
             }
-            // Step 2: Load fresh data from API
+            // Step 2: Load fresh data from API (user resolves independently; Redux gets user as soon as getUser returns)
             const parallelStartTime = Date.now();
-            const [herdModulesResult, userResult] = await Promise.all([
-                (async () => {
+            const userPromise = (async () => {
+                const start = Date.now();
+                const { data } = await supabase.auth.getUser();
+                const duration = Date.now() - start;
+                timingRefs.current.userApiDuration = duration;
+                dispatch(setUserApiDuration(duration));
+                if (!data.user) {
+                    throw new Error("Invalid user response");
+                }
+                dispatch(setUser(data.user));
+                return data.user;
+            })();
+            let herdModulesResult;
+            try {
+                herdModulesResult = await (async () => {
                     const start = Date.now();
                     const result = await server_load_herd_modules();
                     const totalDuration = Date.now() - start;
                     const serverDuration = result.server_processing_time_ms || totalDuration;
                     return { result, totalDuration, serverDuration, start };
-                })(),
-                (async () => {
-                    const start = Date.now();
-                    const { data } = await supabase.auth.getUser();
-                    const duration = Date.now() - start;
-                    return {
-                        result: { data: data.user, status: "success" },
-                        duration,
-                        start,
-                    };
-                })(),
-            ]);
+                })();
+            }
+            catch (e) {
+                await userPromise.catch(() => { });
+                throw e;
+            }
+            await userPromise;
             const parallelDuration = Date.now() - parallelStartTime;
-            console.log(`[useScoutRefresh] Parallel API requests completed in ${parallelDuration}ms`);
+            console.log(`[useScoutRefresh] API requests completed in ${parallelDuration}ms`);
             // Extract results and timing
             const herdModulesResponse = herdModulesResult.result;
-            const res_new_user = userResult.result;
             const herdModulesServerDuration = herdModulesResult.serverDuration;
             const herdModulesTotalDuration = herdModulesResult.totalDuration;
-            const userApiDuration = userResult.duration;
             const clientOverhead = herdModulesTotalDuration - herdModulesServerDuration;
             console.log(`[useScoutRefresh] Fresh API timing breakdown:`);
             console.log(`  - Server processing: ${herdModulesServerDuration}ms`);
@@ -262,20 +268,15 @@ export function useScoutRefresh(options = {}) {
             console.log(`  - Total request: ${herdModulesTotalDuration}ms`);
             // Store timing values
             timingRefs.current.herdModulesDuration = herdModulesServerDuration;
-            timingRefs.current.userApiDuration = userApiDuration;
             // Dispatch timing actions
             dispatch(setHerdModulesApiServerProcessingDuration(herdModulesServerDuration));
             dispatch(setHerdModulesApiTotalRequestDuration(herdModulesTotalDuration));
-            dispatch(setUserApiDuration(userApiDuration));
             // Validate API responses
             const validationStartTime = Date.now();
             if (!herdModulesResponse.data ||
                 !Array.isArray(herdModulesResponse.data)) {
                 throw new Error("Invalid herd modules response");
             }
-            if (!res_new_user || !res_new_user.data) {
-                throw new Error("Invalid user response");
-            }
             const validationDuration = Date.now() - validationStartTime;
             console.log(`[useScoutRefresh] Data validation took: ${validationDuration}ms`);
             // Use the validated data
@@ -305,8 +306,6 @@ export function useScoutRefresh(options = {}) {
             // Update store with new data
             console.log(`[useScoutRefresh] Updating store with fresh herd modules`);
             dispatch(setHerdModules(compatible_new_herd_modules));
-            console.log(`[useScoutRefresh] Updating store with fresh user data`);
-            dispatch(setUser(res_new_user.data));
             dispatch(setHerdModulesLoadingState(EnumHerdModulesLoadingState.SUCCESSFULLY_LOADED));
             const dataProcessingDuration = Date.now() - dataProcessingStartTime;
             timingRefs.current.dataProcessingDuration = dataProcessingDuration;

package/dist/index.d.ts

@@ -55,6 +55,8 @@ export * from "./hooks/useScoutRealtimeSessions";
 export * from "./hooks/useScoutRealtimeParts";
 export * from "./hooks/useScoutRealtimePlans";
 export * from "./hooks/useScoutRealtimePins";
+export * from "./hooks/useScoutRealtimeAnalysisJobs";
+export * from "./hooks/useScoutRealtimeAnalysisTasks";
 export * from "./hooks/useScoutRefresh";
 export * from "./hooks/useInfiniteQuery";
 export * from "./providers";

package/dist/index.js

@@ -59,6 +59,8 @@ export * from "./hooks/useScoutRealtimeSessions";
 export * from "./hooks/useScoutRealtimeParts";
 export * from "./hooks/useScoutRealtimePlans";
 export * from "./hooks/useScoutRealtimePins";
+export * from "./hooks/useScoutRealtimeAnalysisJobs";
+export * from "./hooks/useScoutRealtimeAnalysisTasks";
 export * from "./hooks/useScoutRefresh";
 export * from "./hooks/useInfiniteQuery";
 // Providers

package/dist/providers/ScoutRefreshProvider.d.ts

@@ -700,6 +700,8 @@ export declare function useSupabase(): SupabaseClient<Database, "public", "publi
         };
         herds: {
             Row: {
+                auto_delete_media_with_humans: boolean | null;
+                auto_delete_media_with_no_tracks: boolean | null;
                 created_by: string;
                 description: string;
                 earthranger_domain: string | null;
@@ -714,6 +716,8 @@ export declare function useSupabase(): SupabaseClient<Database, "public", "publi
                 video_subscriber_token: string | null;
             };
             Insert: {
+                auto_delete_media_with_humans?: boolean | null;
+                auto_delete_media_with_no_tracks?: boolean | null;
                 created_by: string;
                 description: string;
                 earthranger_domain?: string | null;
@@ -728,6 +732,8 @@ export declare function useSupabase(): SupabaseClient<Database, "public", "publi
                 video_subscriber_token?: string | null;
             };
             Update: {
+                auto_delete_media_with_humans?: boolean | null;
+                auto_delete_media_with_no_tracks?: boolean | null;
                 created_by?: string;
                 description?: string;
                 earthranger_domain?: string | null;
@@ -1615,6 +1621,10 @@ export declare function useSupabase(): SupabaseClient<Database, "public", "publi
                 isSetofReturn: true;
             };
         };
+        auto_assign_session_post_approver: {
+            Args: never;
+            Returns: number;
+        };
         check_realtime_schema_status: {
             Args: never;
             Returns: {
@@ -2620,6 +2630,10 @@ export declare function useSupabase(): SupabaseClient<Database, "public", "publi
                 isSetofReturn: true;
             };
         };
+        is_platform_superadmin_current_user: {
+            Args: never;
+            Returns: boolean;
+        };
         load_api_keys: {
             Args: {
                 id_of_device: number;
@@ -2911,6 +2925,8 @@ export declare function useSupabase(): SupabaseClient<Database, "public", "publi
             location: string | null;
             latitude: number | null;
             longitude: number | null;
+            auto_delete_media_with_humans: boolean | null;
+            auto_delete_media_with_no_tracks: boolean | null;
         };
         pins_pretty_location: {
             id: number | null;

package/dist/types/supabase.d.ts

@@ -733,6 +733,8 @@ export type Database = {
             };
             herds: {
                 Row: {
+                    auto_delete_media_with_humans: boolean | null;
+                    auto_delete_media_with_no_tracks: boolean | null;
                     created_by: string;
                     description: string;
                     earthranger_domain: string | null;
@@ -747,6 +749,8 @@ export type Database = {
                     video_subscriber_token: string | null;
                 };
                 Insert: {
+                    auto_delete_media_with_humans?: boolean | null;
+                    auto_delete_media_with_no_tracks?: boolean | null;
                     created_by: string;
                     description: string;
                     earthranger_domain?: string | null;
@@ -761,6 +765,8 @@ export type Database = {
                     video_subscriber_token?: string | null;
                 };
                 Update: {
+                    auto_delete_media_with_humans?: boolean | null;
+                    auto_delete_media_with_no_tracks?: boolean | null;
                     created_by?: string;
                     description?: string;
                     earthranger_domain?: string | null;
@@ -1700,6 +1706,10 @@ export type Database = {
                     isSetofReturn: true;
                 };
             };
+            auto_assign_session_post_approver: {
+                Args: never;
+                Returns: number;
+            };
             check_realtime_schema_status: {
                 Args: never;
                 Returns: {
@@ -2705,6 +2715,10 @@ export type Database = {
                     isSetofReturn: true;
                 };
             };
+            is_platform_superadmin_current_user: {
+                Args: never;
+                Returns: boolean;
+            };
             load_api_keys: {
                 Args: {
                     id_of_device: number;
@@ -2996,6 +3010,8 @@ export type Database = {
                 location: string | null;
                 latitude: number | null;
                 longitude: number | null;
+                auto_delete_media_with_humans: boolean | null;
+                auto_delete_media_with_no_tracks: boolean | null;
             };
             pins_pretty_location: {
                 id: number | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adventurelabs/scout-core",
-  "version": "1.4.48",
+  "version": "1.4.50",
   "description": "Core utilities and helpers for Adventure Labs Scout applications",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",