[Security Solution][Sourcerer] Replace Sourcerer with Discover Data View Picker

x-pack/solutions/security/plugins/security_solution/common/experimental_features.ts

@@ -262,6 +262,9 @@ export const allowedExperimentalValues = Object.freeze({
    * Enables banner for informing users about changes in data collection.
    */
   eventCollectionDataReductionBannerEnabled: false,
+
+  /** Enables new Data View Picker */
+  newDataViewPickerEnabled: false,
 });
 
 type ExperimentalConfigKeys = Array<keyof ExperimentalFeatures>;

x-pack/solutions/security/plugins/security_solution/public/app/home/index.tsx

@@ -27,6 +27,7 @@ import { useSetupDetectionEngineHealthApi } from '../../detection_engine/rule_mo
 import { TopValuesPopover } from '../components/top_values_popover/top_values_popover';
 import { AssistantOverlay } from '../../assistant/overlay';
 import { useInitSourcerer } from '../../sourcerer/containers/use_init_sourcerer';
+import { useInitDataViewPicker } from '../../data_view_picker/hooks/use_init_data_view_picker';
 
 interface HomePageProps {
   children: React.ReactNode;
@@ -38,6 +39,7 @@ const HomePageComponent: React.FC<HomePageProps> = ({ children }) => {
   useUrlState();
   useUpdateBrowserTitle();
   useUpdateExecutionContext();
+  useInitDataViewPicker();
 
   const { browserFields } = useSourcererDataView(getScopeFromPath(pathname));
 

x-pack/solutions/security/plugins/security_solution/public/common/components/with_data_view/index.test.tsx

@@ -9,6 +9,7 @@ import type { DataView } from '@kbn/data-views-plugin/common';
 import { render, screen } from '@testing-library/react';
 import { withDataView } from '.';
 import { useGetScopedSourcererDataView } from '../../../sourcerer/components/use_get_sourcerer_data_view';
+import { TestProviders } from '../../mock';
 
 interface TestComponentProps {
   dataView: DataView;
@@ -39,18 +40,18 @@ describe('withDataViewId', () => {
   });
   it('should render default error components when there is not fallback provided and dataViewId is null', async () => {
     const RenderedComponent = withDataView(TestComponent);
-    render(<RenderedComponent />);
+    render(<RenderedComponent />, { wrapper: TestProviders });
     expect(screen.getByTestId(TEST_ID.DATA_VIEW_ERROR_COMPONENT)).toBeVisible();
   });
   it('should render provided fallback and dataViewId is null', async () => {
     const RenderedComponent = withDataView(TestComponent, <FallbackComponent />);
-    render(<RenderedComponent />);
+    render(<RenderedComponent />, { wrapper: TestProviders });
     expect(screen.getByTestId(TEST_ID.FALLBACK_COMPONENT)).toBeVisible();
   });
   it('should render provided component when dataViewId is not null', async () => {
     (useGetScopedSourcererDataView as jest.Mock).mockReturnValue({ id: 'test' });
     const RenderedComponent = withDataView(TestComponent);
-    render(<RenderedComponent />);
+    render(<RenderedComponent />, { wrapper: TestProviders });
     expect(screen.getByTestId(TEST_ID.TEST_COMPONENT)).toBeVisible();
     expect(dataViewMockFn).toHaveBeenCalledWith({ id: 'test' });
   });

x-pack/solutions/security/plugins/security_solution/public/common/components/with_data_view/index.tsx

@@ -9,7 +9,11 @@ import React from 'react';
 import type { ComponentType } from 'react';
 import type { ReactElement } from 'react-markdown';
 import type { DataView } from '@kbn/data-views-plugin/common';
+import { DataViewPickerScopeName } from '../../../data_view_picker/constants';
+import { useFullDataView } from '../../../data_view_picker/hooks/use_full_data_view';
 import { DataViewErrorComponent } from './data_view_error';
+import { useEnableExperimental } from '../../hooks/use_experimental_features';
+
 import { useGetScopedSourcererDataView } from '../../../sourcerer/components/use_get_sourcerer_data_view';
 import { SourcererScopeName } from '../../../sourcerer/store/model';
 
@@ -30,10 +34,19 @@ export const withDataView = <P extends WithDataViewArg>(
   fallback?: ReactElement
 ) => {
   const ComponentWithDataView = (props: OmitDataView<P>) => {
-    const dataView = useGetScopedSourcererDataView({
+    const experimentalDataView = useFullDataView({
+      dataViewPickerScope: DataViewPickerScopeName.timeline,
+    });
+
+    let dataView = useGetScopedSourcererDataView({
       sourcererScope: SourcererScopeName.timeline,
     });
 
+    const { newDataViewPickerEnabled } = useEnableExperimental();
+    if (newDataViewPickerEnabled) {
+      dataView = experimentalDataView;
+    }
+
     if (!dataView) {
       return fallback ?? <DataViewErrorComponent />;
     }

x-pack/solutions/security/plugins/security_solution/public/common/hooks/__mocks__/use_experimental_features.ts

@@ -17,3 +17,5 @@ export const useIsExperimentalFeatureEnabled = jest
 
     throw new Error(`Invalid experimental value ${feature}}`);
   });
+
+export const useEnableExperimental = jest.fn(() => ({ newDataViewPickerEnabled: false }));

x-pack/solutions/security/plugins/security_solution/public/common/hooks/timeline/use_investigate_in_timeline.ts

@@ -8,17 +8,19 @@
 import { useCallback } from 'react';
 import { useDispatch, useSelector } from 'react-redux';
 import type { Filter, Query } from '@kbn/es-query';
+import { useSelectDataView } from '../../../data_view_picker/hooks/use_select_data_view';
 import { useCreateTimeline } from '../../../timelines/hooks/use_create_timeline';
 import { updateProviders, setFilters, applyKqlFilterQuery } from '../../../timelines/store/actions';
 import { SourcererScopeName } from '../../../sourcerer/store/model';
 import type { DataProvider } from '../../../../common/types';
 import { sourcererSelectors } from '../../store';
-import { sourcererActions } from '../../store/actions';
 import { inputsActions } from '../../store/inputs';
 import { InputsModelId } from '../../store/inputs/constants';
 import type { TimeRange } from '../../store/inputs/model';
 import { TimelineId } from '../../../../common/types/timeline';
 import { TimelineTypeEnum } from '../../../../common/api/timeline';
+import { sourcererActions } from '../../store/actions';
+import { useEnableExperimental } from '../use_experimental_features';
 
 interface InvestigateInTimelineArgs {
   /**
@@ -57,6 +59,7 @@ export const useInvestigateInTimeline = () => {
 
   const signalIndexName = useSelector(sourcererSelectors.signalIndexName);
   const defaultDataView = useSelector(sourcererSelectors.defaultDataView);
+  const { newDataViewPickerEnabled } = useEnableExperimental();
 
   const clearTimelineTemplate = useCreateTimeline({
     timelineId: TimelineId.active,
@@ -68,6 +71,8 @@ export const useInvestigateInTimeline = () => {
     timelineType: TimelineTypeEnum.default,
   });
 
+  const setSelectedDataView = useSelectDataView();
+
   const investigateInTimeline = useCallback(
     async ({
       query,
@@ -124,19 +129,35 @@ export const useInvestigateInTimeline = () => {
         // Only show detection alerts
         // (This is required so the timeline event count matches the prevalence count)
         if (!keepDataView) {
-          dispatch(
-            sourcererActions.setSelectedDataView({
-              id: SourcererScopeName.timeline,
-              selectedDataViewId: defaultDataView.id,
-              selectedPatterns: [signalIndexName || ''],
-            })
-          );
+          if (newDataViewPickerEnabled) {
+            setSelectedDataView({
+              scope: [SourcererScopeName.timeline],
+              id: defaultDataView.id,
+              fallbackPatterns: [signalIndexName || ''],
+            });
+          } else {
+            dispatch(
+              sourcererActions.setSelectedDataView({
+                id: SourcererScopeName.timeline,
+                selectedDataViewId: defaultDataView.id,
+                selectedPatterns: [signalIndexName || ''],
+              })
+            );
+          }
         }
         // Unlock the time range from the global time range
         dispatch(inputsActions.removeLinkTo([InputsModelId.timeline, InputsModelId.global]));
       }
     },
-    [clearTimelineTemplate, clearTimelineDefault, dispatch, defaultDataView.id, signalIndexName]
+    [
+      clearTimelineTemplate,
+      clearTimelineDefault,
+      dispatch,
+      newDataViewPickerEnabled,
+      setSelectedDataView,
+      defaultDataView.id,
+      signalIndexName,
+    ]
   );
 
   return { investigateInTimeline };

x-pack/solutions/security/plugins/security_solution/public/common/mock/global_state.ts

@@ -48,6 +48,7 @@ import { initialGroupingState } from '../store/grouping/reducer';
 import type { SourcererState } from '../../sourcerer/store';
 import { EMPTY_RESOLVER } from '../../resolver/store/helpers';
 import { getMockDiscoverInTimelineState } from './mock_discover_state';
+import { mockDataViewPickerState } from '../../data_view_picker/redux/mock';
 
 const mockFieldMap: DataViewSpec['fields'] = Object.fromEntries(
   mockIndexFields.map((field) => [field.name, field])
@@ -554,4 +555,5 @@ export const mockGlobalState: State = {
     selectedIds: [],
     pendingDeleteIds: [],
   },
+  ...mockDataViewPickerState,
 };

x-pack/solutions/security/plugins/security_solution/public/common/store/middlewares.ts

@@ -7,13 +7,17 @@
 
 import type { CoreStart } from '@kbn/core/public';
 import type { Storage } from '@kbn/kibana-utils-plugin/public';
+import { createListenerMiddleware } from '@reduxjs/toolkit';
 
 import { createTimelineMiddlewares } from '../../timelines/store/middlewares/create_timeline_middlewares';
 import { dataTableLocalStorageMiddleware } from './data_table/middleware_local_storage';
 import { userAssetTableLocalStorageMiddleware } from '../../explore/users/store/middleware_storage';
 
+const listenerMiddleware = createListenerMiddleware();
+
 export function createMiddlewares(kibana: CoreStart, storage: Storage) {
   return [
+    listenerMiddleware.middleware,
     dataTableLocalStorageMiddleware(storage),
     userAssetTableLocalStorageMiddleware(storage),
     ...createTimelineMiddlewares(kibana),

x-pack/solutions/security/plugins/security_solution/public/common/store/reducer.ts

@@ -37,6 +37,10 @@ import { securitySolutionDiscoverReducer } from './discover/reducer';
 import type { AnalyzerState } from '../../resolver/types';
 import type { NotesState } from '../../notes/store/notes.slice';
 import { notesReducer } from '../../notes/store/notes.slice';
+import {
+  dataViewPickerReducer,
+  initialDataViewPickerState,
+} from '../../data_view_picker/redux/reducer';
 
 enableMapSet();
 
@@ -132,6 +136,7 @@ export const createInitialState = (
       savedSearch: undefined,
     },
     notes: notesState,
+    dataViewPicker: initialDataViewPickerState.dataViewPicker,
   };
 
   return preloadedState;
@@ -155,4 +160,5 @@ export const createReducer: (
     discover: securitySolutionDiscoverReducer,
     ...pluginsReducer,
     notes: notesReducer,
+    dataViewPicker: dataViewPickerReducer,
   });

x-pack/solutions/security/plugins/security_solution/public/common/store/types.ts

@@ -26,6 +26,7 @@ import type { GroupState } from './grouping/types';
 import type { SecuritySolutionDiscoverState } from './discover/model';
 import type { AnalyzerState } from '../../resolver/types';
 import type { NotesState } from '../../notes/store/notes.slice';
+import type { RootState as DataViewPickerState } from '../../data_view_picker/redux/reducer';
 
 export type State = HostsPluginState &
   UsersPluginState &
@@ -40,7 +41,7 @@ export type State = HostsPluginState &
     discover: SecuritySolutionDiscoverState;
   } & DataTableState &
   GroupState &
-  AnalyzerState & { notes: NotesState };
+  AnalyzerState & { notes: NotesState } & DataViewPickerState;
 /**
  * The Redux store type for the Security app.
  */

x-pack/solutions/security/plugins/security_solution/public/common/utils/timeline/use_show_timeline.test.tsx

@@ -13,8 +13,11 @@ import { appLinks } from '../../../app_links';
 import { useUserPrivileges } from '../../components/user_privileges';
 import { useShowTimeline } from './use_show_timeline';
 import { uiSettingsServiceMock } from '@kbn/core-ui-settings-browser-mocks';
+import { TestProviders } from '../../mock';
+import { hasAccessToSecuritySolution } from '../../../helpers_access';
 
 jest.mock('../../components/user_privileges');
+jest.mock('../../../helpers_access', () => ({ hasAccessToSecuritySolution: jest.fn(() => true) }));
 
 const mockUseLocation = jest.fn().mockReturnValue({ pathname: '/overview' });
 jest.mock('react-router-dom', () => {
@@ -35,30 +38,11 @@ jest.mock('../../../sourcerer/containers', () => ({
   useSourcererDataView: () => mockUseSourcererDataView(),
 }));
 
-const mockSiemUserCanRead = jest.fn(() => true);
-jest.mock('../../lib/kibana', () => {
-  const original = jest.requireActual('../../lib/kibana');
-
-  return {
-    ...original,
-    useKibana: () => ({
-      services: {
-        ...original.useKibana().services,
-        application: {
-          capabilities: {
-            siemV2: {
-              show: mockSiemUserCanRead(),
-            },
-          },
-        },
-      },
-    }),
-  };
-});
-
 const mockUpselling = new UpsellingService();
 const mockUiSettingsClient = uiSettingsServiceMock.createStartContract();
 
+const renderUseShowTimeline = () => renderHook(() => useShowTimeline(), { wrapper: TestProviders });
+
 describe('use show timeline', () => {
   beforeAll(() => {
     (useUserPrivileges as unknown as jest.Mock).mockReturnValue({
@@ -84,33 +68,33 @@ describe('use show timeline', () => {
   });
 
   it('shows timeline for routes on default', async () => {
-    const { result } = renderHook(() => useShowTimeline());
+    const { result } = renderUseShowTimeline();
     await waitFor(() => expect(result.current).toEqual([true]));
   });
 
   it('hides timeline for blacklist routes', async () => {
     mockUseLocation.mockReturnValueOnce({ pathname: '/rules/add_rules' });
-    const { result } = renderHook(() => useShowTimeline());
+    const { result } = renderUseShowTimeline();
     await waitFor(() => expect(result.current).toEqual([false]));
   });
 
   it('shows timeline for partial blacklist routes', async () => {
     mockUseLocation.mockReturnValueOnce({ pathname: '/rules' });
-    const { result } = renderHook(() => useShowTimeline());
+    const { result } = renderUseShowTimeline();
     await waitFor(() => expect(result.current).toEqual([true]));
   });
 
   it('hides timeline for sub blacklist routes', async () => {
     mockUseLocation.mockReturnValueOnce({ pathname: '/administration/policy' });
-    const { result } = renderHook(() => useShowTimeline());
+    const { result } = renderUseShowTimeline();
     await waitFor(() => expect(result.current).toEqual([false]));
   });
   it('hides timeline for users without timeline access', async () => {
     (useUserPrivileges as unknown as jest.Mock).mockReturnValue({
       timelinePrivileges: { read: false },
     });
 
-    const { result } = renderHook(() => useShowTimeline());
+    const { result } = renderUseShowTimeline();
     const showTimeline = result.current;
     expect(showTimeline).toEqual([false]);
   });
@@ -120,41 +104,40 @@ it('shows timeline for users with timeline read access', async () => {
     timelinePrivileges: { read: true },
   });
 
-  const { result } = renderHook(() => useShowTimeline());
+  const { result } = renderUseShowTimeline();
   const showTimeline = result.current;
   expect(showTimeline).toEqual([true]);
 });
 
 describe('sourcererDataView', () => {
   it('should show timeline when indices exist', () => {
     mockUseSourcererDataView.mockReturnValueOnce({ indicesExist: true, dataViewId: 'test' });
-    const { result } = renderHook(() => useShowTimeline());
+    const { result } = renderUseShowTimeline();
     expect(result.current).toEqual([true]);
   });
 
   it('should show timeline when dataViewId is null', () => {
     mockUseSourcererDataView.mockReturnValueOnce({ indicesExist: false, dataViewId: null });
-    const { result } = renderHook(() => useShowTimeline());
+    const { result } = renderUseShowTimeline();
     expect(result.current).toEqual([true]);
   });
 
   it('should not show timeline when dataViewId is not null and indices does not exist', () => {
     mockUseSourcererDataView.mockReturnValueOnce({ indicesExist: false, dataViewId: 'test' });
-    const { result } = renderHook(() => useShowTimeline());
+    const { result } = renderUseShowTimeline();
     expect(result.current).toEqual([false]);
   });
 });
 
 describe('Security solution capabilities', () => {
   it('should show timeline when user has read capabilities', () => {
-    mockSiemUserCanRead.mockReturnValueOnce(true);
-    const { result } = renderHook(() => useShowTimeline());
+    const { result } = renderUseShowTimeline();
     expect(result.current).toEqual([true]);
   });
 
   it('should not show timeline when user does not have read capabilities', () => {
-    mockSiemUserCanRead.mockReturnValueOnce(false);
-    const { result } = renderHook(() => useShowTimeline());
+    jest.mocked(hasAccessToSecuritySolution).mockReturnValueOnce(false);
+    const { result } = renderUseShowTimeline();
     expect(result.current).toEqual([false]);
   });
 });