@adventurelabs/scout-core 1.2.5 → 1.3.1

package/dist/hooks/useInfiniteQuery.js

@@ -0,0 +1,360 @@
+import { useState, useCallback, useMemo, useEffect } from "react";
+import { useGetSessionsInfiniteByHerdQuery, useGetSessionsInfiniteByDeviceQuery, useGetEventsInfiniteByHerdQuery, useGetEventsInfiniteByDeviceQuery, useGetArtifactsInfiniteByHerdQuery, useGetArtifactsInfiniteByDeviceQuery, } from "../store/api";
+// =====================================================
+// SESSIONS INFINITE SCROLL HOOKS
+// =====================================================
+export const useInfiniteSessionsByHerd = (herdId, options) => {
+    const [pages, setPages] = useState([]);
+    const [currentCursor, setCurrentCursor] = useState(null);
+    const currentQuery = useGetSessionsInfiniteByHerdQuery({
+        herdId,
+        limit: options.limit || 20,
+        cursor: currentCursor,
+        supabase: options.supabase,
+    }, {
+        skip: !options.enabled,
+    });
+    // Update pages when new data arrives
+    useEffect(() => {
+        if (currentQuery.data && !currentQuery.isLoading) {
+            setPages((prev) => {
+                const existingPage = prev.find((p) => (p.cursor === null && currentCursor === null) ||
+                    (p.cursor &&
+                        currentCursor &&
+                        p.cursor.id === currentCursor.id &&
+                        p.cursor.timestamp === currentCursor.timestamp));
+                if (!existingPage) {
+                    return [
+                        ...prev,
+                        { cursor: currentCursor, data: currentQuery.data.sessions },
+                    ];
+                }
+                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]);
+    // Flatten all pages into single array
+    const allItems = useMemo(() => {
+        return 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,
+    };
+};
+export const useInfiniteSessionsByDevice = (deviceId, options) => {
+    const [pages, setPages] = useState([]);
+    const [currentCursor, setCurrentCursor] = useState(null);
+    const currentQuery = useGetSessionsInfiniteByDeviceQuery({
+        deviceId,
+        limit: options.limit || 20,
+        cursor: currentCursor,
+        supabase: options.supabase,
+    }, {
+        skip: !options.enabled,
+    });
+    useEffect(() => {
+        if (currentQuery.data && !currentQuery.isLoading) {
+            setPages((prev) => {
+                const existingPage = prev.find((p) => (p.cursor === null && currentCursor === null) ||
+                    (p.cursor &&
+                        currentCursor &&
+                        p.cursor.id === currentCursor.id &&
+                        p.cursor.timestamp === currentCursor.timestamp));
+                if (!existingPage) {
+                    return [
+                        ...prev,
+                        { cursor: currentCursor, data: currentQuery.data.sessions },
+                    ];
+                }
+                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(() => {
+        return 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,
+    };
+};
+// =====================================================
+// EVENTS INFINITE SCROLL HOOKS
+// =====================================================
+export const useInfiniteEventsByHerd = (herdId, options) => {
+    const [pages, setPages] = useState([]);
+    const [currentCursor, setCurrentCursor] = useState(null);
+    const currentQuery = useGetEventsInfiniteByHerdQuery({
+        herdId,
+        limit: options.limit || 20,
+        cursor: currentCursor,
+        supabase: options.supabase,
+    }, {
+        skip: !options.enabled,
+    });
+    useEffect(() => {
+        if (currentQuery.data && !currentQuery.isLoading) {
+            setPages((prev) => {
+                const existingPage = prev.find((p) => (p.cursor === null && currentCursor === null) ||
+                    (p.cursor &&
+                        currentCursor &&
+                        p.cursor.id === currentCursor.id &&
+                        p.cursor.timestamp === currentCursor.timestamp));
+                if (!existingPage) {
+                    return [
+                        ...prev,
+                        { cursor: currentCursor, data: currentQuery.data.events },
+                    ];
+                }
+                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(() => {
+        return 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,
+    };
+};
+export const useInfiniteEventsByDevice = (deviceId, options) => {
+    const [pages, setPages] = useState([]);
+    const [currentCursor, setCurrentCursor] = useState(null);
+    const currentQuery = useGetEventsInfiniteByDeviceQuery({
+        deviceId,
+        limit: options.limit || 20,
+        cursor: currentCursor,
+        supabase: options.supabase,
+    }, {
+        skip: !options.enabled,
+    });
+    useEffect(() => {
+        if (currentQuery.data && !currentQuery.isLoading) {
+            setPages((prev) => {
+                const existingPage = prev.find((p) => (p.cursor === null && currentCursor === null) ||
+                    (p.cursor &&
+                        currentCursor &&
+                        p.cursor.id === currentCursor.id &&
+                        p.cursor.timestamp === currentCursor.timestamp));
+                if (!existingPage) {
+                    return [
+                        ...prev,
+                        { cursor: currentCursor, data: currentQuery.data.events },
+                    ];
+                }
+                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(() => {
+        return 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,
+    };
+};
+// =====================================================
+// ARTIFACTS INFINITE SCROLL HOOKS
+// =====================================================
+export const useInfiniteArtifactsByHerd = (herdId, options) => {
+    const [pages, setPages] = useState([]);
+    const [currentCursor, setCurrentCursor] = useState(null);
+    const currentQuery = useGetArtifactsInfiniteByHerdQuery({
+        herdId,
+        limit: options.limit || 20,
+        cursor: currentCursor,
+        supabase: options.supabase,
+    }, {
+        skip: !options.enabled,
+    });
+    useEffect(() => {
+        if (currentQuery.data && !currentQuery.isLoading) {
+            setPages((prev) => {
+                const existingPage = prev.find((p) => (p.cursor === null && currentCursor === null) ||
+                    (p.cursor &&
+                        currentCursor &&
+                        p.cursor.id === currentCursor.id &&
+                        p.cursor.timestamp === currentCursor.timestamp));
+                if (!existingPage) {
+                    return [
+                        ...prev,
+                        { cursor: currentCursor, data: currentQuery.data.artifacts },
+                    ];
+                }
+                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(() => {
+        return 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,
+    };
+};
+export const useInfiniteArtifactsByDevice = (deviceId, options) => {
+    const [pages, setPages] = useState([]);
+    const [currentCursor, setCurrentCursor] = useState(null);
+    const currentQuery = useGetArtifactsInfiniteByDeviceQuery({
+        deviceId,
+        limit: options.limit || 20,
+        cursor: currentCursor,
+        supabase: options.supabase,
+    }, {
+        skip: !options.enabled,
+    });
+    useEffect(() => {
+        if (currentQuery.data && !currentQuery.isLoading) {
+            setPages((prev) => {
+                const existingPage = prev.find((p) => (p.cursor === null && currentCursor === null) ||
+                    (p.cursor &&
+                        currentCursor &&
+                        p.cursor.id === currentCursor.id &&
+                        p.cursor.timestamp === currentCursor.timestamp));
+                if (!existingPage) {
+                    return [
+                        ...prev,
+                        { cursor: currentCursor, data: currentQuery.data.artifacts },
+                    ];
+                }
+                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(() => {
+        return 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
+// =====================================================
+export const useIntersectionObserver = (callback, options = {}) => {
+    const [element, setElement] = useState(null);
+    useEffect(() => {
+        if (!element)
+            return;
+        const observer = new IntersectionObserver((entries) => {
+            const first = entries[0];
+            if (first.isIntersecting) {
+                callback();
+            }
+        }, { threshold: 0.1, ...options });
+        observer.observe(element);
+        return () => {
+            if (element) {
+                observer.unobserve(element);
+            }
+        };
+    }, [element, callback, options]);
+    return setElement;
+};

package/dist/hooks/useScoutRealtimeEvents.d.ts

@@ -2,4 +2,4 @@ import { SupabaseClient } from "@supabase/supabase-js";
 import { Database } from "../types/supabase";
 import { IEventAndTagsPrettyLocation } from "../types/db";
 import { RealtimeData } from "../types/realtime";
-export declare function useScoutRealtimeEvents(scoutSupabase: SupabaseClient<Database>, shouldUpdateGlobalStateOnChanges: boolean): [RealtimeData<IEventAndTagsPrettyLocation> | null, () => void];
+export declare function useScoutRealtimeEvents(scoutSupabase: SupabaseClient<Database>, invalidateRTKQuery?: boolean): [RealtimeData<IEventAndTagsPrettyLocation> | null, () => void];

package/dist/hooks/useScoutRealtimeEvents.js

@@ -2,9 +2,9 @@
 import { useAppDispatch } from "../store/hooks";
 import { useSelector } from "react-redux";
 import { useEffect, useRef, useCallback, useState } from "react";
-import { updateEventValuesForHerdModule } from "../store/scout";
 import { EnumRealtimeOperation } from "../types/realtime";
-export function useScoutRealtimeEvents(scoutSupabase, shouldUpdateGlobalStateOnChanges) {
+import { scoutApi } from "../store/api";
+export function useScoutRealtimeEvents(scoutSupabase, invalidateRTKQuery = true) {
     const channels = useRef([]);
     const dispatch = useAppDispatch();
     const [latestEventUpdate, setLatestEventUpdate] = useState(null);
@@ -17,37 +17,32 @@ export function useScoutRealtimeEvents(scoutSupabase, shouldUpdateGlobalStateOnC
         if (!eventData)
             return;
         let operation;
-        // TODO: UNCOMMENT GLOBAL STORE OPERATIONS IF OKAY WITH FREQUENT
         switch (data.operation) {
             case "INSERT":
                 operation = EnumRealtimeOperation.INSERT;
-                if (data.record && activeHerdId && shouldUpdateGlobalStateOnChanges) {
-                    console.log("[Events] New event received:", data.record);
-                    // For events, we need to update the event values in the herd module
-                    dispatch(updateEventValuesForHerdModule({
-                        herd_id: activeHerdId,
-                        events: [data.record],
-                    }));
+                if (data.record && invalidateRTKQuery) {
+                    console.log("[Events] New event received, invalidating RTK Query cache:", data.record);
+                    // Invalidate all events queries to refetch fresh data
+                    dispatch(scoutApi.util.invalidateTags(["Event"]));
                 }
                 break;
             case "UPDATE":
                 operation = EnumRealtimeOperation.UPDATE;
-                if (data.record && activeHerdId && shouldUpdateGlobalStateOnChanges) {
-                    console.log("[Events] Event updated:", data.record);
-                    dispatch(updateEventValuesForHerdModule({
-                        herd_id: activeHerdId,
-                        events: [data.record],
-                    }));
+                if (data.record && invalidateRTKQuery) {
+                    console.log("[Events] Event updated, invalidating RTK Query cache:", data.record);
+                    // Invalidate specific event and list queries
+                    dispatch(scoutApi.util.invalidateTags([
+                        { type: "Event", id: data.record.id || "unknown" },
+                        { type: "Event", id: "LIST" },
+                    ]));
                 }
                 break;
             case "DELETE":
                 operation = EnumRealtimeOperation.DELETE;
-                if (data.old_record &&
-                    activeHerdId &&
-                    shouldUpdateGlobalStateOnChanges) {
-                    console.log("[Events] Event deleted:", data.old_record);
-                    // TODO: WRITE DELETION STORE ACTION
-                    console.log("[Events] Event deletion detected - manual refresh may be needed");
+                if (data.old_record && invalidateRTKQuery) {
+                    console.log("[Events] Event deleted, invalidating RTK Query cache:", data.old_record);
+                    // Invalidate all events queries since item was deleted
+                    dispatch(scoutApi.util.invalidateTags(["Event"]));
                 }
                 break;
             default:
@@ -59,7 +54,7 @@ export function useScoutRealtimeEvents(scoutSupabase, shouldUpdateGlobalStateOnC
         };
         console.log(`[scout-core realtime] EVENT ${data.operation} received:`, JSON.stringify(realtimeData));
         setLatestEventUpdate(realtimeData);
-    }, [dispatch, activeHerdId]);
+    }, [dispatch, invalidateRTKQuery]);
     // Clear latest update
     const clearLatestUpdate = useCallback(() => {
         setLatestEventUpdate(null);

package/dist/hooks/useScoutRealtimeSessions.d.ts

@@ -2,4 +2,4 @@ import { SupabaseClient } from "@supabase/supabase-js";
 import { Database } from "../types/supabase";
 import { ISessionWithCoordinates } from "../types/db";
 import { RealtimeData } from "../types/realtime";
-export declare function useScoutRealtimeSessions(scoutSupabase: SupabaseClient<Database>, shouldUpdateGlobalStateOnChanges: boolean): [RealtimeData<ISessionWithCoordinates> | null, () => void];
+export declare function useScoutRealtimeSessions(scoutSupabase: SupabaseClient<Database>, invalidateRTKQuery?: boolean): [RealtimeData<ISessionWithCoordinates> | null, () => void];

package/dist/hooks/useScoutRealtimeSessions.js

@@ -1,10 +1,10 @@
 "use client";
-import { useAppDispatch } from "../store/hooks";
 import { useSelector } from "react-redux";
+import { useAppDispatch } from "../store/hooks";
 import { useEffect, useRef, useCallback, useState } from "react";
-import { addSessionToStore, deleteSessionFromStore, updateSessionInStore, } from "../store/scout";
 import { EnumRealtimeOperation } from "../types/realtime";
-export function useScoutRealtimeSessions(scoutSupabase, shouldUpdateGlobalStateOnChanges) {
+import { scoutApi } from "../store/api";
+export function useScoutRealtimeSessions(scoutSupabase, invalidateRTKQuery = true) {
     const channels = useRef([]);
     const dispatch = useAppDispatch();
     const [latestSessionUpdate, setLatestSessionUpdate] = useState(null);
@@ -20,21 +20,29 @@ export function useScoutRealtimeSessions(scoutSupabase, shouldUpdateGlobalStateO
         switch (data.operation) {
             case "INSERT":
                 operation = EnumRealtimeOperation.INSERT;
-                if (data.record && shouldUpdateGlobalStateOnChanges) {
-                    console.log("[Sessions] New session received:", data.record);
-                    dispatch(addSessionToStore(data.record));
+                if (data.record && invalidateRTKQuery) {
+                    console.log("[Sessions] New session received, invalidating RTK Query cache:", data.record);
+                    // Invalidate all sessions queries to refetch fresh data
+                    dispatch(scoutApi.util.invalidateTags(["Session"]));
                 }
                 break;
             case "UPDATE":
                 operation = EnumRealtimeOperation.UPDATE;
-                if (data.record && shouldUpdateGlobalStateOnChanges) {
-                    dispatch(updateSessionInStore(data.record));
+                if (data.record && invalidateRTKQuery) {
+                    console.log("[Sessions] Session updated, invalidating RTK Query cache:", data.record);
+                    // Invalidate specific session and list queries
+                    dispatch(scoutApi.util.invalidateTags([
+                        { type: "Session", id: data.record.id || "unknown" },
+                        { type: "Session", id: "LIST" },
+                    ]));
                 }
                 break;
             case "DELETE":
                 operation = EnumRealtimeOperation.DELETE;
-                if (data.old_record && shouldUpdateGlobalStateOnChanges) {
-                    dispatch(deleteSessionFromStore(data.old_record));
+                if (data.old_record && invalidateRTKQuery) {
+                    console.log("[Sessions] Session deleted, invalidating RTK Query cache:", data.old_record);
+                    // Invalidate all sessions queries since item was deleted
+                    dispatch(scoutApi.util.invalidateTags(["Session"]));
                 }
                 break;
             default:
@@ -46,7 +54,7 @@ export function useScoutRealtimeSessions(scoutSupabase, shouldUpdateGlobalStateO
         };
         console.log(`[scout-core realtime] SESSION ${data.operation} received:`, JSON.stringify(realtimeData));
         setLatestSessionUpdate(realtimeData);
-    }, [dispatch]);
+    }, [invalidateRTKQuery, dispatch]);
     // Clear latest update
     const clearLatestUpdate = useCallback(() => {
         setLatestSessionUpdate(null);
@@ -78,6 +86,6 @@ export function useScoutRealtimeSessions(scoutSupabase, shouldUpdateGlobalStateO
             channels.current.push(channel);
         }
         return cleanupChannels;
-    }, [activeHerdId, clearLatestUpdate]);
+    }, [activeHerdId, clearLatestUpdate, handleSessionBroadcast]);
     return [latestSessionUpdate, clearLatestUpdate];
 }

package/dist/hooks/useScoutRealtimeTags.d.ts

@@ -2,4 +2,4 @@ import { SupabaseClient } from "@supabase/supabase-js";
 import { Database } from "../types/supabase";
 import { ITagPrettyLocation } from "../types/db";
 import { RealtimeData } from "../types/realtime";
-export declare function useScoutRealtimeTags(scoutSupabase: SupabaseClient<Database>, shouldUpdateGlobalStateOnChanges: boolean): [RealtimeData<ITagPrettyLocation> | null, () => void];
+export declare function useScoutRealtimeTags(scoutSupabase: SupabaseClient<Database>, invalidateRTKQuery?: boolean): [RealtimeData<ITagPrettyLocation> | null, () => void];

package/dist/hooks/useScoutRealtimeTags.js

@@ -2,9 +2,9 @@
 import { useAppDispatch } from "../store/hooks";
 import { useSelector } from "react-redux";
 import { useEffect, useRef, useCallback, useState } from "react";
-import { addTag, deleteTag, updateTag } from "../store/scout";
 import { EnumRealtimeOperation } from "../types/realtime";
-export function useScoutRealtimeTags(scoutSupabase, shouldUpdateGlobalStateOnChanges) {
+import { scoutApi } from "../store/api";
+export function useScoutRealtimeTags(scoutSupabase, invalidateRTKQuery = true) {
     const channels = useRef([]);
     const dispatch = useAppDispatch();
     const [latestTagUpdate, setLatestTagUpdate] = useState(null);
@@ -20,23 +20,26 @@ export function useScoutRealtimeTags(scoutSupabase, shouldUpdateGlobalStateOnCha
         switch (data.operation) {
             case "INSERT":
                 operation = EnumRealtimeOperation.INSERT;
-                if (data.record && shouldUpdateGlobalStateOnChanges) {
-                    console.log("[Tags] New tag received:", data.record);
-                    dispatch(addTag(data.record));
+                if (data.record && invalidateRTKQuery) {
+                    console.log("[Tags] New tag received, invalidating RTK Query cache:", data.record);
+                    // Tags are part of events, so invalidate events queries
+                    dispatch(scoutApi.util.invalidateTags(["Event"]));
                 }
                 break;
             case "UPDATE":
                 operation = EnumRealtimeOperation.UPDATE;
-                if (data.record && shouldUpdateGlobalStateOnChanges) {
-                    console.log("[Tags] Tag updated:", data.record);
-                    dispatch(updateTag(data.record));
+                if (data.record && invalidateRTKQuery) {
+                    console.log("[Tags] Tag updated, invalidating RTK Query cache:", data.record);
+                    // Invalidate events queries since tags are embedded in events
+                    dispatch(scoutApi.util.invalidateTags(["Event"]));
                 }
                 break;
             case "DELETE":
                 operation = EnumRealtimeOperation.DELETE;
-                if (data.old_record && shouldUpdateGlobalStateOnChanges) {
-                    console.log("[Tags] Tag deleted:", data.old_record);
-                    dispatch(deleteTag(data.old_record));
+                if (data.old_record && invalidateRTKQuery) {
+                    console.log("[Tags] Tag deleted, invalidating RTK Query cache:", data.old_record);
+                    // Invalidate events queries since tags are embedded in events
+                    dispatch(scoutApi.util.invalidateTags(["Event"]));
                 }
                 break;
             default:
@@ -48,7 +51,7 @@ export function useScoutRealtimeTags(scoutSupabase, shouldUpdateGlobalStateOnCha
         };
         console.log(`[scout-core realtime] TAG ${data.operation} received:`, JSON.stringify(realtimeData));
         setLatestTagUpdate(realtimeData);
-    }, [dispatch]);
+    }, [dispatch, invalidateRTKQuery]);
     // Clear latest update
     const clearLatestUpdate = useCallback(() => {
         setLatestTagUpdate(null);

package/dist/index.d.ts

@@ -48,6 +48,7 @@ export * from "./hooks/useScoutRealtimeSessions";
 export * from "./hooks/useScoutRealtimePlans";
 export * from "./hooks/useScoutRealtimePins";
 export * from "./hooks/useScoutRefresh";
+export * from "./hooks/useInfiniteQuery";
 export * from "./providers";
 export * from "./store/scout";
 export * from "./store/hooks";

package/dist/index.js

@@ -52,6 +52,7 @@ export * from "./hooks/useScoutRealtimeSessions";
 export * from "./hooks/useScoutRealtimePlans";
 export * from "./hooks/useScoutRealtimePins";
 export * from "./hooks/useScoutRefresh";
+export * from "./hooks/useInfiniteQuery";
 // Providers
 export * from "./providers";
 // Store