@cccsaurora/howler-ui 2.19.0-cases.863 → 2.19.0-dev.1023

package/components/app/providers/{RecordSearchProvider.js → HitSearchProvider.js}

@@ -13,12 +13,12 @@ import { createContext, useContextSelector } from 'use-context-selector';
 import { DEFAULT_QUERY, StorageKey } from '@cccsaurora/howler-ui/utils/constants';
 import Throttler from '@cccsaurora/howler-ui/utils/Throttler';
 import { convertCustomDateRangeToLucene, convertDateToLucene } from '@cccsaurora/howler-ui/utils/utils';
+import { HitContext } from './HitProvider';
 import { ParameterContext } from './ParameterProvider';
-import { RecordContext } from './RecordProvider';
 import { ViewContext } from './ViewProvider';
-export const RecordSearchContext = createContext(null);
+export const HitSearchContext = createContext(null);
 const THROTTLER = new Throttler(500);
-const RecordSearchProvider = ({ children }) => {
+const HitSearchProvider = ({ children }) => {
     const { get } = useMyLocalStorage();
     const routeParams = useParams();
     const location = useLocation();
@@ -33,13 +33,12 @@ const RecordSearchProvider = ({ children }) => {
     const trackTotalHits = useContextSelector(ParameterContext, ctx => ctx.trackTotalHits);
     const sort = useContextSelector(ParameterContext, ctx => ctx.sort);
     const span = useContextSelector(ParameterContext, ctx => ctx.span);
-    const indexes = useContextSelector(ParameterContext, ctx => ctx.indexes);
     const allFilters = useContextSelector(ParameterContext, ctx => ctx.filters);
     const startDate = useContextSelector(ParameterContext, ctx => ctx.startDate);
     const endDate = useContextSelector(ParameterContext, ctx => ctx.endDate);
     const views = useContextSelector(ParameterContext, ctx => ctx.views);
     const addView = useContextSelector(ParameterContext, ctx => ctx.addView);
-    const loadHits = useContextSelector(RecordContext, ctx => ctx.loadRecords);
+    const loadHits = useContextSelector(HitContext, ctx => ctx.loadHits);
     const [displayType, setDisplayType] = useState(get(StorageKey.DISPLAY_TYPE) ?? 'list');
     const [searching, setSearching] = useState(false);
     const [error, setError] = useState(null);
@@ -48,6 +47,7 @@ const RecordSearchProvider = ({ children }) => {
         'howler.id: *': new Date().toISOString()
     });
     const [fzfSearch, setFzfSearch] = useState(false);
+    const bundleId = useMemo(() => (location.pathname.startsWith('/bundles') ? routeParams.id : null), [location.pathname, routeParams.id]);
     const filters = useMemo(() => allFilters.filter(filter => !filter.endsWith('*')), [allFilters]);
     // On load check to filter out any queries older than one month
     useEffect(() => {
@@ -70,6 +70,11 @@ const RecordSearchProvider = ({ children }) => {
         else if (startDate && endDate) {
             _filters.push(`event.created:${convertCustomDateRangeToLucene(startDate, endDate)}`);
         }
+        // Add bundle filter
+        const bundle = location.pathname.startsWith('/bundles') && routeParams.id;
+        if (bundle) {
+            _filters.push(`howler.bundles:${bundle}`);
+        }
         // Fetch all view queries
         if (views.length > 0) {
             const viewObjects = await getCurrentViews({ views });
@@ -80,7 +85,7 @@ const RecordSearchProvider = ({ children }) => {
                 .forEach(viewQuery => _filters.push(viewQuery));
         }
         return _filters;
-    }, [endDate, filters, getCurrentViews, span, startDate, views]);
+    }, [endDate, filters, getCurrentViews, location.pathname, routeParams.id, span, startDate, views]);
     const search = useCallback(async (_query, appendResults) => {
         THROTTLER.debounce(async () => {
             if (_query === 'woof!') {
@@ -100,7 +105,7 @@ const RecordSearchProvider = ({ children }) => {
             setSearching(true);
             setError(null);
             try {
-                const _response = await dispatchApi(api.v2.search.post(indexes, {
+                const _response = await dispatchApi(api.search.hit.post({
                     offset: appendResults && response ? response.rows : offset,
                     rows: pageCount,
                     query: _query || DEFAULT_QUERY,
@@ -144,7 +149,6 @@ const RecordSearchProvider = ({ children }) => {
         startDate,
         endDate,
         filters,
-        indexes,
         setQuery,
         location.pathname,
         routeParams.id,
@@ -163,15 +167,15 @@ const RecordSearchProvider = ({ children }) => {
         if (span?.endsWith('custom') && (!startDate || !endDate)) {
             return;
         }
-        if (views.length > 0 || (query && query !== DEFAULT_QUERY) || offset > 0 || filters.length > 0) {
+        if (views.length > 0 || bundleId || (query && query !== DEFAULT_QUERY) || offset > 0 || filters.length > 0) {
             search(query);
         }
         else {
             setResponse(null);
         }
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [offset, pageCount, sort, span, indexes, location.pathname, startDate, endDate, filters, query, views]);
-    return (_jsx(RecordSearchContext.Provider, { value: {
+    }, [offset, pageCount, sort, span, bundleId, location.pathname, startDate, endDate, filters, query, views]);
+    return (_jsx(HitSearchContext.Provider, { value: {
             displayType,
             setDisplayType,
             search,
@@ -179,10 +183,11 @@ const RecordSearchProvider = ({ children }) => {
             getFilters,
             error,
             response,
+            bundleId,
             setQueryHistory,
             queryHistory,
             fzfSearch,
             setFzfSearch
         }, children: children }));
 };
-export default RecordSearchProvider;
+export default HitSearchProvider;

package/components/app/providers/{RecordSearchProvider.test.js → HitSearchProvider.test.js}

@@ -5,9 +5,9 @@ import { cloneDeep } from 'lodash-es';
 import { setupContextSelectorMock, setupLocalStorageMock } from '@cccsaurora/howler-ui/tests/mocks';
 import { useContextSelector } from 'use-context-selector';
 import { DEFAULT_QUERY, MY_LOCAL_STORAGE_PREFIX, StorageKey } from '@cccsaurora/howler-ui/utils/constants';
+import { HitContext } from './HitProvider';
+import HitSearchProvider, { HitSearchContext } from './HitSearchProvider';
 import { ParameterContext } from './ParameterProvider';
-import { RecordContext } from './RecordProvider';
-import RecordSearchProvider, { RecordSearchContext } from './RecordSearchProvider';
 import { ViewContext } from './ViewProvider';
 vi.mock('api', { spy: true });
 setupContextSelectorMock();
@@ -30,21 +30,20 @@ let mockParameterContext = {
         mockParameterContext.offset = parseInt(offset);
     },
     views: [],
-    indexes: ['hit'],
     addView: vi.fn()
 };
 const originalMockParameterContext = cloneDeep(mockParameterContext);
 const mockHitContext = {
-    records: {},
-    loadRecords: hits => {
-        mockHitContext.records = {
-            ...mockHitContext.records,
+    hits: {},
+    loadHits: hits => {
+        mockHitContext.hits = {
+            ...mockHitContext.hits,
             ...Object.fromEntries(hits.map(hit => [hit.howler.id, hit]))
         };
     }
 };
 const Wrapper = ({ children }) => {
-    return (_jsx(ViewContext.Provider, { value: mockViewContext, children: _jsx(ParameterContext.Provider, { value: mockParameterContext, children: _jsx(RecordContext.Provider, { value: mockHitContext, children: _jsx(RecordSearchProvider, { children: children }) }) }) }));
+    return (_jsx(ViewContext.Provider, { value: mockViewContext, children: _jsx(ParameterContext.Provider, { value: mockParameterContext, children: _jsx(HitContext.Provider, { value: mockHitContext, children: _jsx(HitSearchProvider, { children: children }) }) }) }));
 };
 beforeEach(() => {
     mockParameterContext = cloneDeep(originalMockParameterContext);
@@ -58,32 +57,38 @@ beforeEach(() => {
     let mockSearchParams = new URLSearchParams();
     vi.mocked(useSearchParams).mockReturnValue([mockSearchParams, mockSetParams]);
 });
-describe('RecordSearchContext', () => {
+describe('HitSearchContext', () => {
     it('should initialize with default values', async () => {
-        const hook = renderHook(() => useContextSelector(RecordSearchContext, ctx => ({
+        const hook = renderHook(() => useContextSelector(HitSearchContext, ctx => ({
             displayType: ctx.displayType,
             searching: ctx.searching,
             error: ctx.error,
             response: ctx.response,
+            bundleId: ctx.bundleId,
             fzfSearch: ctx.fzfSearch
         })), { wrapper: Wrapper });
         expect(hook.result.current.displayType).toBe('list');
         expect(hook.result.current.searching).toBe(false);
         expect(hook.result.current.error).toBeNull();
         expect(hook.result.current.response).toBeNull();
+        expect(hook.result.current.bundleId).toBeNull();
         expect(hook.result.current.fzfSearch).toBe(false);
     });
+    it('should set bundleId when on bundles route', () => {
+        mockLocation.pathname = '/bundles/test_bundle_id';
+        mockParams.mockReturnValue({ id: 'test_bundle_id' });
+        const hook = renderHook(() => useContextSelector(HitSearchContext, ctx => ctx.bundleId), { wrapper: Wrapper });
+        expect(hook.result.current).toBe('test_bundle_id');
+    });
     it('should initialize queryHistory from localStorage', () => {
         const mockHistory = { 'test:query': new Date().toISOString() };
         mockLocalStorage.setItem(`${MY_LOCAL_STORAGE_PREFIX}.${StorageKey.QUERY_HISTORY}`, JSON.stringify(mockHistory));
-        const hook = renderHook(() => useContextSelector(RecordSearchContext, ctx => ctx.queryHistory), {
-            wrapper: Wrapper
-        });
+        const hook = renderHook(() => useContextSelector(HitSearchContext, ctx => ctx.queryHistory), { wrapper: Wrapper });
         expect(hook.result.current).toEqual(mockHistory);
     });
     describe('setDisplayType', () => {
         it('should update display type', () => {
-            const hook = renderHook(() => useContextSelector(RecordSearchContext, ctx => ({
+            const hook = renderHook(() => useContextSelector(HitSearchContext, ctx => ({
                 displayType: ctx.displayType,
                 setDisplayType: ctx.setDisplayType
             })), { wrapper: Wrapper });
@@ -96,7 +101,7 @@ describe('RecordSearchContext', () => {
     });
     describe('setFzfSearch', () => {
         it('should update fzfSearch state', () => {
-            const hook = renderHook(() => useContextSelector(RecordSearchContext, ctx => ({
+            const hook = renderHook(() => useContextSelector(HitSearchContext, ctx => ({
                 fzfSearch: ctx.fzfSearch,
                 setFzfSearch: ctx.setFzfSearch
             })), { wrapper: Wrapper });
@@ -109,7 +114,7 @@ describe('RecordSearchContext', () => {
     });
     describe('setQueryHistory', () => {
         it('should update query history', () => {
-            const hook = renderHook(() => useContextSelector(RecordSearchContext, ctx => ({
+            const hook = renderHook(() => useContextSelector(HitSearchContext, ctx => ({
                 queryHistory: ctx.queryHistory,
                 setQueryHistory: ctx.setQueryHistory
             })), { wrapper: Wrapper });
@@ -122,7 +127,7 @@ describe('RecordSearchContext', () => {
     });
     describe('search', () => {
         it('should perform a search and update response', async () => {
-            const hook = renderHook(() => useContextSelector(RecordSearchContext, ctx => ({
+            const hook = renderHook(() => useContextSelector(HitSearchContext, ctx => ({
                 search: ctx.search,
                 searching: ctx.searching,
                 response: ctx.response,
@@ -132,13 +137,13 @@ describe('RecordSearchContext', () => {
                 hook.result.current.search('test query');
             });
             await waitFor(() => {
-                expect(hpost).toHaveBeenCalledWith('/api/v2/search/hit', expect.objectContaining({
+                expect(hpost).toHaveBeenCalledWith('/api/v1/search/hit', expect.objectContaining({
                     query: expect.stringContaining('test query')
                 }));
             });
         });
         it('should set searching state during search', async () => {
-            const hook = renderHook(() => useContextSelector(RecordSearchContext, ctx => ({
+            const hook = renderHook(() => useContextSelector(HitSearchContext, ctx => ({
                 search: ctx.search,
                 searching: ctx.searching
             })), { wrapper: Wrapper });
@@ -167,7 +172,7 @@ describe('RecordSearchContext', () => {
         });
         it('should handle search errors', async () => {
             vi.mocked(hpost).mockRejectedValueOnce(new Error('Search failed'));
-            const hook = renderHook(() => useContextSelector(RecordSearchContext, ctx => ({
+            const hook = renderHook(() => useContextSelector(HitSearchContext, ctx => ({
                 search: ctx.search,
                 error: ctx.error,
                 searching: ctx.searching
@@ -188,7 +193,7 @@ describe('RecordSearchContext', () => {
                 total: 10
             };
             vi.mocked(hpost).mockResolvedValueOnce(mockResponse);
-            const hook = renderHook(() => useContextSelector(RecordSearchContext, ctx => ({
+            const hook = renderHook(() => useContextSelector(HitSearchContext, ctx => ({
                 search: ctx.search,
                 response: ctx.response
             })), { wrapper: Wrapper });
@@ -224,7 +229,7 @@ describe('RecordSearchContext', () => {
                 total: 10
             };
             vi.mocked(hpost).mockResolvedValueOnce(mockResponse);
-            const hook = renderHook(() => useContextSelector(RecordSearchContext, ctx => ({
+            const hook = renderHook(() => useContextSelector(HitSearchContext, ctx => ({
                 search: ctx.search,
                 response: ctx.response
             })), { wrapper: Wrapper });
@@ -238,13 +243,27 @@ describe('RecordSearchContext', () => {
                 expect(hook.result.current.response?.items[0].howler.id).toBe('hit1');
             });
         });
+        it('should include bundle filter when on bundles route', async () => {
+            mockLocation.pathname = '/bundles/test_bundle_id';
+            mockParams.mockReturnValue({ id: 'test_bundle_id' });
+            const hook = renderHook(() => useContextSelector(HitSearchContext, ctx => ctx.search), { wrapper: Wrapper });
+            act(() => {
+                hook.result.current('test query');
+            });
+            await waitFor(() => {
+                expect(hpost).toHaveBeenCalledWith('/api/v1/search/hit', expect.objectContaining({
+                    query: 'test query',
+                    filters: ['event.created:[now-1w TO now]', 'howler.bundles:test_bundle_id']
+                }));
+            });
+        });
         it('should apply date range filter from span', async () => {
-            const hook = renderHook(() => useContextSelector(RecordSearchContext, ctx => ctx.search), { wrapper: Wrapper });
+            const hook = renderHook(() => useContextSelector(HitSearchContext, ctx => ctx.search), { wrapper: Wrapper });
             act(() => {
                 hook.result.current('test query');
             });
             await waitFor(() => {
-                expect(hpost).toHaveBeenCalledWith('/api/v2/search/hit', expect.objectContaining({
+                expect(hpost).toHaveBeenCalledWith('/api/v1/search/hit', expect.objectContaining({
                     filters: expect.arrayContaining([expect.stringContaining('event.created:')])
                 }));
             });
@@ -253,24 +272,24 @@ describe('RecordSearchContext', () => {
             mockParameterContext.span = 'date.range.custom';
             mockParameterContext.startDate = '2025-01-01';
             mockParameterContext.endDate = '2025-12-31';
-            const hook = renderHook(() => useContextSelector(RecordSearchContext, ctx => ctx.search), { wrapper: Wrapper });
+            const hook = renderHook(() => useContextSelector(HitSearchContext, ctx => ctx.search), { wrapper: Wrapper });
             act(() => {
                 hook.result.current('test query');
             });
             await waitFor(() => {
-                expect(hpost).toHaveBeenCalledWith('/api/v2/search/hit', expect.objectContaining({
+                expect(hpost).toHaveBeenCalledWith('/api/v1/search/hit', expect.objectContaining({
                     filters: expect.arrayContaining([expect.stringContaining('event.created:')])
                 }));
             });
         });
         it('should exclude filters ending with * from search', async () => {
             mockParameterContext.filters = ['status:open', 'howler.escalation:*'];
-            const hook = renderHook(() => useContextSelector(RecordSearchContext, ctx => ctx.search), { wrapper: Wrapper });
+            const hook = renderHook(() => useContextSelector(HitSearchContext, ctx => ctx.search), { wrapper: Wrapper });
             act(() => {
                 hook.result.current('test query');
             });
             await waitFor(() => {
-                expect(hpost).toHaveBeenCalledWith('/api/v2/search/hit', expect.objectContaining({
+                expect(hpost).toHaveBeenCalledWith('/api/v1/search/hit', expect.objectContaining({
                     filters: expect.not.arrayContaining([expect.stringContaining('howler.escalation:*')])
                 }));
             });
@@ -283,7 +302,7 @@ describe('RecordSearchContext', () => {
                 rows: 0,
                 total: 50
             });
-            const hook = renderHook(() => useContextSelector(RecordSearchContext, ctx => ({
+            const hook = renderHook(() => useContextSelector(HitSearchContext, ctx => ({
                 search: ctx.search
             })), { wrapper: Wrapper });
             act(() => {
@@ -297,7 +316,7 @@ describe('RecordSearchContext', () => {
         it('should not search when sort or span is null', async () => {
             mockParameterContext.sort = null;
             mockParameterContext.span = null;
-            const hook = renderHook(() => useContextSelector(RecordSearchContext, ctx => ctx.search), { wrapper: Wrapper });
+            const hook = renderHook(() => useContextSelector(HitSearchContext, ctx => ctx.search), { wrapper: Wrapper });
             act(() => {
                 hook.result.current('test query');
             });
@@ -309,7 +328,7 @@ describe('RecordSearchContext', () => {
     });
     describe('automatic search on parameter changes', () => {
         it('should trigger search when filters change', async () => {
-            const hook = renderHook(() => useContextSelector(RecordSearchContext, ctx => ({
+            const hook = renderHook(() => useContextSelector(HitSearchContext, ctx => ({
                 response: ctx.response
             })), { wrapper: Wrapper });
             await waitFor(() => {
@@ -323,23 +342,23 @@ describe('RecordSearchContext', () => {
                 expect(hpost).toHaveBeenCalled();
             }, { timeout: 2000 });
         });
-        it('should not trigger search when query is DEFAULT_QUERY', async () => {
+        it('should not trigger search when query is DEFAULT_QUERY and no bundleId', async () => {
             mockParameterContext.query = DEFAULT_QUERY;
-            renderHook(() => useContextSelector(RecordSearchContext, ctx => ctx.response), { wrapper: Wrapper });
+            renderHook(() => useContextSelector(HitSearchContext, ctx => ctx.response), { wrapper: Wrapper });
             await waitFor(() => {
                 expect(hpost).not.toHaveBeenCalled();
             });
         });
         it('should not trigger search when span is custom but dates are missing', async () => {
-            renderHook(() => useContextSelector(RecordSearchContext, ctx => ctx.response), { wrapper: Wrapper });
+            renderHook(() => useContextSelector(HitSearchContext, ctx => ctx.response), { wrapper: Wrapper });
             await waitFor(() => {
                 expect(hpost).not.toHaveBeenCalled();
             });
         });
     });
-    describe('useRecordSearchContextSelector', () => {
+    describe('useHitSearchContextSelector', () => {
         it('should allow selecting specific values from context', async () => {
-            const hook = renderHook(() => useContextSelector(RecordSearchContext, ctx => ({
+            const hook = renderHook(() => useContextSelector(HitSearchContext, ctx => ({
                 searching: ctx.searching,
                 error: ctx.error
             })), { wrapper: Wrapper });
@@ -349,7 +368,7 @@ describe('RecordSearchContext', () => {
     });
     describe('edge cases', () => {
         it('should handle concurrent search calls with throttling', async () => {
-            const hook = renderHook(() => useContextSelector(RecordSearchContext, ctx => ctx.search), { wrapper: Wrapper });
+            const hook = renderHook(() => useContextSelector(HitSearchContext, ctx => ctx.search), { wrapper: Wrapper });
             // Make multiple rapid calls
             act(() => {
                 hook.result.current('query1');
@@ -361,8 +380,8 @@ describe('RecordSearchContext', () => {
                 expect(hpost).toHaveBeenCalledTimes(1);
             }, { timeout: 2000 });
         });
-        it('should clear response when query becomes DEFAULT_QUERY without viewId', async () => {
-            const hook = renderHook(() => useContextSelector(RecordSearchContext, ctx => ctx.response), { wrapper: Wrapper });
+        it('should clear response when query becomes DEFAULT_QUERY without viewId or bundleId', async () => {
+            const hook = renderHook(() => useContextSelector(HitSearchContext, ctx => ctx.response), { wrapper: Wrapper });
             await waitFor(() => {
                 expect(hook.result.current).toBeDefined();
             }, { timeout: 2000 });
@@ -382,12 +401,12 @@ describe('RecordSearchContext', () => {
                     { view_id: 'view_1', query: 'howler.status:open' },
                     { view_id: 'view_2', query: 'howler.priority:high' }
                 ]);
-                const hook = renderHook(() => useContextSelector(RecordSearchContext, ctx => ctx.search), { wrapper: Wrapper });
+                const hook = renderHook(() => useContextSelector(HitSearchContext, ctx => ctx.search), { wrapper: Wrapper });
                 act(() => {
                     hook.result.current('test query');
                 });
                 await waitFor(() => {
-                    expect(hpost).toHaveBeenCalledWith('/api/v2/search/hit', expect.objectContaining({
+                    expect(hpost).toHaveBeenCalledWith('/api/v1/search/hit', expect.objectContaining({
                         query: 'test query',
                         filters: expect.arrayContaining(['howler.status:open', 'howler.priority:high'])
                     }));
@@ -400,12 +419,12 @@ describe('RecordSearchContext', () => {
                     { view_id: 'view_2', query: 'howler.priority:high' },
                     { view_id: 'view_3', query: 'howler.analytic:sigma' }
                 ]);
-                const hook = renderHook(() => useContextSelector(RecordSearchContext, ctx => ctx.search), { wrapper: Wrapper });
+                const hook = renderHook(() => useContextSelector(HitSearchContext, ctx => ctx.search), { wrapper: Wrapper });
                 act(() => {
                     hook.result.current('test query');
                 });
                 await waitFor(() => {
-                    expect(hpost).toHaveBeenCalledWith('/api/v2/search/hit', expect.objectContaining({
+                    expect(hpost).toHaveBeenCalledWith('/api/v1/search/hit', expect.objectContaining({
                         query: 'test query',
                         filters: [
                             'event.created:[now-1w TO now]',
@@ -424,7 +443,7 @@ describe('RecordSearchContext', () => {
                 mockParameterContext.views = [];
                 const mockSearchParams = new URLSearchParams();
                 vi.mocked(useSearchParams).mockReturnValue([mockSearchParams, mockSetParams]);
-                renderHook(() => useContextSelector(RecordSearchContext, () => { }), { wrapper: Wrapper });
+                renderHook(() => useContextSelector(HitSearchContext, () => { }), { wrapper: Wrapper });
                 await waitFor(() => {
                     expect(mockParameterContext.addView).toBeCalledWith('default_view_id');
                 });
@@ -436,7 +455,7 @@ describe('RecordSearchContext', () => {
                 const mockSearchParams = new URLSearchParams();
                 mockSearchParams.append('view', 'existing_view');
                 vi.mocked(useSearchParams).mockReturnValue([mockSearchParams, mockSetParams]);
-                renderHook(() => useContextSelector(RecordSearchContext, () => { }), { wrapper: Wrapper });
+                renderHook(() => useContextSelector(HitSearchContext, () => { }), { wrapper: Wrapper });
                 await waitFor(() => {
                     expect(mockParameterContext.addView).not.toBeCalled();
                 });
@@ -447,7 +466,7 @@ describe('RecordSearchContext', () => {
                 mockParameterContext.views = [];
                 const mockSearchParams = new URLSearchParams();
                 vi.mocked(useSearchParams).mockReturnValue([mockSearchParams, mockSetParams]);
-                renderHook(() => useContextSelector(RecordSearchContext, () => { }), { wrapper: Wrapper });
+                renderHook(() => useContextSelector(HitSearchContext, () => { }), { wrapper: Wrapper });
                 await waitFor(() => {
                     expect(mockSetParams).not.toHaveBeenCalled();
                 });
@@ -457,12 +476,12 @@ describe('RecordSearchContext', () => {
             it('should not break when view ID does not exist', async () => {
                 mockParameterContext.views = ['non_existent_view'];
                 mockViewContext.getCurrentViews = vi.fn(() => Promise.resolve([null]));
-                const hook = renderHook(() => useContextSelector(RecordSearchContext, ctx => ctx.search), { wrapper: Wrapper });
+                const hook = renderHook(() => useContextSelector(HitSearchContext, ctx => ctx.search), { wrapper: Wrapper });
                 act(() => {
                     hook.result.current('test query');
                 });
                 await waitFor(() => {
-                    expect(hpost).toHaveBeenCalledWith('/api/v2/search/hit', expect.objectContaining({
+                    expect(hpost).toHaveBeenCalledWith('/api/v1/search/hit', expect.objectContaining({
                         query: expect.stringContaining('test query'),
                         filters: ['event.created:[now-1w TO now]']
                     }));
@@ -474,12 +493,12 @@ describe('RecordSearchContext', () => {
                     { view_id: 'view_1', query: 'howler.status:open' },
                     { view_id: 'view_2', query: 'howler.priority:high' }
                 ]);
-                const hook = renderHook(() => useContextSelector(RecordSearchContext, ctx => ctx.search), { wrapper: Wrapper });
+                const hook = renderHook(() => useContextSelector(HitSearchContext, ctx => ctx.search), { wrapper: Wrapper });
                 act(() => {
                     hook.result.current('test query');
                 });
                 await waitFor(() => {
-                    expect(hpost).toHaveBeenCalledWith('/api/v2/search/hit', expect.objectContaining({
+                    expect(hpost).toHaveBeenCalledWith('/api/v1/search/hit', expect.objectContaining({
                         query: 'test query',
                         filters: ['event.created:[now-1w TO now]', 'howler.status:open', 'howler.priority:high']
                     }));
@@ -490,7 +509,7 @@ describe('RecordSearchContext', () => {
             it('should not trigger search when views is empty and query is DEFAULT_QUERY', async () => {
                 mockParameterContext.query = DEFAULT_QUERY;
                 mockParameterContext.views = [];
-                renderHook(() => useContextSelector(RecordSearchContext, ctx => ctx.response), { wrapper: Wrapper });
+                renderHook(() => useContextSelector(HitSearchContext, ctx => ctx.response), { wrapper: Wrapper });
                 await waitFor(() => {
                     expect(hpost).not.toHaveBeenCalled();
                 });
@@ -498,7 +517,7 @@ describe('RecordSearchContext', () => {
             it('should trigger search when views.length > 0 even with DEFAULT_QUERY', async () => {
                 mockParameterContext.query = DEFAULT_QUERY;
                 mockParameterContext.views = ['view_1'];
-                renderHook(() => useContextSelector(RecordSearchContext, ctx => ctx.response), { wrapper: Wrapper });
+                renderHook(() => useContextSelector(HitSearchContext, ctx => ctx.response), { wrapper: Wrapper });
                 await waitFor(() => {
                     expect(hpost).toHaveBeenCalled();
                 });

package/components/app/providers/ModalProvider.d.ts

@@ -1,12 +1,12 @@
 import type { FC, PropsWithChildren, ReactNode } from 'react';
 export interface ModalOptions {
     disableClose?: boolean;
-    height?: number | string | null;
     maxWidth?: string;
     maxHeight?: string;
 }
 interface ModalContextType {
     showModal: (children: ReactNode, options?: ModalOptions) => () => void;
+    withConfirmDeleteModal: (onConfirm: () => void, preferDelete?: boolean, preferCancel?: boolean) => () => void;
     content?: ReactNode;
     setContent: (children: ReactNode) => void;
     options?: ModalOptions;

package/components/app/providers/ModalProvider.js

@@ -1,4 +1,5 @@
 import { jsx as _jsx } from "react/jsx-runtime";
+import ConfirmDeleteModal from '@cccsaurora/howler-ui/components/elements/display/modals/ConfirmDeleteModal';
 import { createContext, useCallback, useEffect, useState } from 'react';
 const defaultOptions = {
     disableClose: false
@@ -23,6 +24,9 @@ const ModalProvider = ({ children }) => {
         return () => setContent(null);
     }, [options]);
     const close = useCallback(() => setContent(null), []);
-    return (_jsx(ModalContext.Provider, { value: { showModal, content, setContent, options, close }, children: children }));
+    const withConfirmDeleteModal = useCallback((onConfirm, preferDelete, preferCancel) => {
+        return showModal(_jsx(ConfirmDeleteModal, { onConfirm: onConfirm, preferDelete: preferDelete, preferCancel: preferCancel }));
+    }, [showModal]);
+    return (_jsx(ModalContext.Provider, { value: { showModal, withConfirmDeleteModal, content, setContent, options, close }, children: children }));
 };
 export default ModalProvider;

package/components/app/providers/ParameterProvider.d.ts

@@ -1,5 +1,4 @@
 import type { FC, PropsWithChildren } from 'react';
-export type SearchIndex = 'hit' | 'observable' | 'case';
 export interface ParameterContextType {
     selected?: string;
     query?: string;
@@ -7,7 +6,6 @@ export interface ParameterContextType {
     trackTotalHits: boolean;
     sort?: string;
     span?: string;
-    indexes?: SearchIndex[];
     filters?: string[];
     startDate?: string;
     endDate?: string;
@@ -21,16 +19,11 @@ export interface ParameterContextType {
     addFilter: (filter: string) => void;
     removeFilter: (filter: string) => void;
     setFilter: (index: number, filter: string) => void;
-    resetFilters: () => void;
-    addIndex: (index: SearchIndex) => void;
-    removeIndex: (index: SearchIndex) => void;
-    setIndex: (position: number, index: SearchIndex) => void;
-    setIndexes: (indexes: SearchIndex[]) => void;
-    resetIndexes: () => void;
+    clearFilters: () => void;
     addView: (view: string) => void;
     removeView: (view: string) => void;
     setView: (index: number, view: string) => void;
-    resetViews: () => void;
+    clearViews: () => void;
 }
 export declare const ParameterContext: import("use-context-selector").Context<ParameterContextType>;
 /**