[Search Session] Fix integration in vega, timelion and TSVB

src/plugins/data/public/public.api.md

@@ -2624,7 +2624,7 @@ export const UI_SETTINGS: {
 // src/plugins/data/public/index.ts:433:1 - (ae-forgotten-export) The symbol "propFilter" needs to be exported by the entry point index.d.ts
 // src/plugins/data/public/index.ts:436:1 - (ae-forgotten-export) The symbol "toAbsoluteDates" needs to be exported by the entry point index.d.ts
 // src/plugins/data/public/query/state_sync/connect_to_query_state.ts:45:5 - (ae-forgotten-export) The symbol "FilterStateStore" needs to be exported by the entry point index.d.ts
-// src/plugins/data/public/search/session/session_service.ts:51:5 - (ae-forgotten-export) The symbol "UrlGeneratorStateMapping" needs to be exported by the entry point index.d.ts
+// src/plugins/data/public/search/session/session_service.ts:52:5 - (ae-forgotten-export) The symbol "UrlGeneratorStateMapping" needs to be exported by the entry point index.d.ts
 
 // (No @packageDocumentation comment for this package)
 

src/plugins/data/public/search/search_interceptor.test.ts

@@ -115,12 +115,14 @@ describe('SearchInterceptor', () => {
       }: {
         isRestore?: boolean;
         isStored?: boolean;
-        sessionId?: string;
+        sessionId: string;
       }) => {
         const sessionServiceMock = searchMock.session as jest.Mocked<ISessionService>;
-        sessionServiceMock.getSessionId.mockImplementation(() => sessionId);
-        sessionServiceMock.isRestore.mockImplementation(() => isRestore);
-        sessionServiceMock.isStored.mockImplementation(() => isStored);
+        sessionServiceMock.getSearchOptions.mockImplementation(() => ({
+          sessionId,
+          isRestore,
+          isStored,
+        }));
         fetchMock.mockResolvedValue({ result: 200 });
       };
 
@@ -130,72 +132,28 @@ describe('SearchInterceptor', () => {
 
       afterEach(() => {
         const sessionServiceMock = searchMock.session as jest.Mocked<ISessionService>;
-        sessionServiceMock.getSessionId.mockReset();
-        sessionServiceMock.isRestore.mockReset();
-        sessionServiceMock.isStored.mockReset();
+        sessionServiceMock.getSearchOptions.mockReset();
         fetchMock.mockReset();
       });
 
-      test('infers isRestore from session service state', async () => {
+      test('gets session search options from session service', async () => {
         const sessionId = 'sid';
         setup({
           isRestore: true,
-          sessionId,
-        });
-
-        await searchInterceptor.search(mockRequest, { sessionId }).toPromise();
-        expect(fetchMock.mock.calls[0][0]).toEqual(
-          expect.objectContaining({
-            options: { sessionId: 'sid', isStored: false, isRestore: true },
-          })
-        );
-      });
-
-      test('infers isStored from session service state', async () => {
-        const sessionId = 'sid';
-        setup({
           isStored: true,
           sessionId,
         });
 
         await searchInterceptor.search(mockRequest, { sessionId }).toPromise();
         expect(fetchMock.mock.calls[0][0]).toEqual(
           expect.objectContaining({
-            options: { sessionId: 'sid', isStored: true, isRestore: false },
-          })
-        );
-      });
-
-      test('skips isRestore & isStore in case not a current session Id', async () => {
-        setup({
-          isStored: true,
-          isRestore: true,
-          sessionId: 'session id',
-        });
-
-        await searchInterceptor
-          .search(mockRequest, { sessionId: 'different session id' })
-          .toPromise();
-        expect(fetchMock.mock.calls[0][0]).toEqual(
-          expect.objectContaining({
-            options: { sessionId: 'different session id', isStored: false, isRestore: false },
+            options: { sessionId, isStored: true, isRestore: true },
           })
         );
-      });
 
-      test('skips isRestore & isStore in case no session Id', async () => {
-        setup({
-          isStored: true,
-          isRestore: true,
-          sessionId: undefined,
-        });
-
-        await searchInterceptor.search(mockRequest, { sessionId: 'sessionId' }).toPromise();
-        expect(fetchMock.mock.calls[0][0]).toEqual(
-          expect.objectContaining({
-            options: { sessionId: 'sessionId', isStored: false, isRestore: false },
-          })
-        );
+        expect(
+          (searchMock.session as jest.Mocked<ISessionService>).getSearchOptions
+        ).toHaveBeenCalledWith(sessionId);
       });
     });
 

src/plugins/data/public/search/search_interceptor.ts

@@ -130,16 +130,12 @@ export class SearchInterceptor {
   ): Promise<IKibanaSearchResponse> {
     const { abortSignal, ...requestOptions } = options || {};
 
-    const isCurrentSession =
-      options?.sessionId && this.deps.session.getSessionId() === options.sessionId;
-
     return this.batchedFetch(
       {
         request,
         options: {
           ...requestOptions,
-          isStored: isCurrentSession ? this.deps.session.isStored() : false,
-          isRestore: isCurrentSession ? this.deps.session.isRestore() : false,
+          ...(options?.sessionId && this.deps.session.getSearchOptions(options.sessionId)),
         },
       },
       abortSignal

src/plugins/data/public/search/session/mocks.ts

@@ -49,5 +49,7 @@ export function getSessionServiceMock(): jest.Mocked<ISessionService> {
     isStored: jest.fn(),
     isRestore: jest.fn(),
     save: jest.fn(),
+    isCurrentSession: jest.fn(),
+    getSearchOptions: jest.fn(),
   };
 }

src/plugins/data/public/search/session/session_service.test.ts

@@ -33,10 +33,18 @@ describe('Session service', () => {
 
   beforeEach(() => {
     const initializerContext = coreMock.createPluginInitializerContext();
+    const startService = coreMock.createSetup().getStartServices;
     nowProvider = createNowProviderMock();
     sessionService = new SessionService(
       initializerContext,
-      coreMock.createSetup().getStartServices,
+      () =>
+        startService().then(([coreStart, ...rest]) => [
+          {
+            ...coreStart,
+            application: { ...coreStart.application, currentAppId$: new BehaviorSubject('app') },
+          },
+          ...rest,
+        ]),
       getSessionsClientMock(),
       nowProvider,
       { freezeState: false } // needed to use mocks inside state container
@@ -100,4 +108,63 @@ describe('Session service', () => {
       expect(abort).toBeCalledTimes(3);
     });
   });
+
+  test('getSearchOptions infers isRestore & isStored from state', async () => {
+    const sessionId = sessionService.start();
+    const someOtherId = 'some-other-id';
+
+    expect(sessionService.getSearchOptions(someOtherId)).toEqual({
+      isStored: false,
+      isRestore: false,
+      sessionId: someOtherId,
+    });
+    expect(sessionService.getSearchOptions(sessionId)).toEqual({
+      isStored: false,
+      isRestore: false,
+      sessionId,
+    });
+
+    sessionService.setSearchSessionInfoProvider({
+      getName: async () => 'Name',
+      getUrlGeneratorData: async () => ({
+        urlGeneratorId: 'id',
+        initialState: {},
+        restoreState: {},
+      }),
+    });
+    await sessionService.save();
+
+    expect(sessionService.getSearchOptions(someOtherId)).toEqual({
+      isStored: false,
+      isRestore: false,
+      sessionId: someOtherId,
+    });
+    expect(sessionService.getSearchOptions(sessionId)).toEqual({
+      isStored: true,
+      isRestore: false,
+      sessionId,
+    });
+
+    await sessionService.restore(sessionId);
+
+    expect(sessionService.getSearchOptions(someOtherId)).toEqual({
+      isStored: false,
+      isRestore: false,
+      sessionId: someOtherId,
+    });
+    expect(sessionService.getSearchOptions(sessionId)).toEqual({
+      isStored: true,
+      isRestore: true,
+      sessionId,
+    });
+  });
+  test('isCurrentSession', () => {
+    expect(sessionService.isCurrentSession()).toBeFalsy();
+
+    const sessionId = sessionService.start();
+
+    expect(sessionService.isCurrentSession()).toBeFalsy();
+    expect(sessionService.isCurrentSession('some-other')).toBeFalsy();
+    expect(sessionService.isCurrentSession(sessionId)).toBeTruthy();
+  });
 });

src/plugins/data/public/search/session/session_service.ts

@@ -29,6 +29,7 @@ import {
   SessionStateContainer,
 } from './search_session_state';
 import { ISessionsClient } from './sessions_client';
+import { ISearchOptions } from '../../../common';
 import { NowProviderInternalContract } from '../../now_provider';
 
 export type ISessionService = PublicContract<SessionService>;
@@ -256,4 +257,27 @@ export class SessionService {
       this.state.transitions.store();
     }
   }
+
+  /**
+   * Checks if passed sessionId is a current sessionId
+   * @param sessionId
+   */
+  public isCurrentSession(sessionId?: string): boolean {
+    return !!sessionId && this.getSessionId() === sessionId;
+  }
+
+  /**
+   * Infers search session options for sessionId using current session state
+   * @param sessionId
+   */
+  public getSearchOptions(
+    sessionId: string
+  ): Required<Pick<ISearchOptions, 'sessionId' | 'isRestore' | 'isStored'>> {
+    const isCurrentSession = this.isCurrentSession(sessionId);
+    return {
+      sessionId,
+      isRestore: isCurrentSession ? this.isRestore() : false,
+      isStored: isCurrentSession ? this.isStored() : false,
+    };
+  }
 }

src/plugins/vis_type_timelion/public/helpers/timelion_request_handler.ts

@@ -73,12 +73,15 @@ export function getTimelionRequestHandler({
     filters,
     query,
     visParams,
+    searchSessionId,
   }: {
     timeRange: TimeRange;
     filters: Filter[];
     query: Query;
     visParams: TimelionVisParams;
+    searchSessionId?: string;
   }): Promise<TimelionSuccessResponse> {
+    const dataSearch = getDataSearch();
     const expression = visParams.expression;
 
     if (!expression) {
@@ -93,7 +96,13 @@ export function getTimelionRequestHandler({
 
     // parse the time range client side to make sure it behaves like other charts
     const timeRangeBounds = timefilter.calculateBounds(timeRange);
-    const sessionId = getDataSearch().session.getSessionId();
+    const untrackSearch =
+      dataSearch.session.isCurrentSession(searchSessionId) &&
+      dataSearch.session.trackSearch({
+        abort: () => {
+          // TODO: support search cancellations
+        },
+      });
 
     try {
       return await http.post('/api/timelion/run', {
@@ -110,7 +119,9 @@ export function getTimelionRequestHandler({
             interval: visParams.interval,
             timezone,
           },
-          sessionId,
+          ...(searchSessionId && {
+            searchSession: dataSearch.session.getSearchOptions(searchSessionId),
+          }),
         }),
       });
     } catch (e) {
@@ -125,6 +136,11 @@ export function getTimelionRequestHandler({
       } else {
         throw e;
       }
+    } finally {
+      if (untrackSearch && dataSearch.session.isCurrentSession(searchSessionId)) {
+        // call `untrack` if this search still belongs to current session
+        untrackSearch();
+      }
     }
   };
 }

src/plugins/vis_type_timelion/public/timelion_vis_fn.ts

@@ -72,7 +72,7 @@ export const getTimelionVisualizationConfig = (
       help: '',
     },
   },
-  async fn(input, args) {
+  async fn(input, args, { getSearchSessionId }) {
     const timelionRequestHandler = getTimelionRequestHandler(dependencies);
 
     const visParams = { expression: args.expression, interval: args.interval };
@@ -82,6 +82,7 @@ export const getTimelionVisualizationConfig = (
       query: get(input, 'query') as Query,
       filters: get(input, 'filters') as Filter[],
       visParams,
+      searchSessionId: getSearchSessionId(),
     });
 
     response.visType = TIMELION_VIS_NAME;

src/plugins/vis_type_timelion/server/routes/run.ts

@@ -75,7 +75,13 @@ export function runRoute(
               to: schema.maybe(schema.string()),
             })
           ),
-          sessionId: schema.maybe(schema.string()),
+          searchSession: schema.maybe(
+            schema.object({
+              sessionId: schema.string(),
+              isRestore: schema.boolean({ defaultValue: false }),
+              isStored: schema.boolean({ defaultValue: false }),
+            })
+          ),
         }),
       },
     },

src/plugins/vis_type_timelion/server/series_functions/es/es.test.js

@@ -60,19 +60,26 @@ describe('es', () => {
         });
     });
 
-    test('should call data search with sessionId', async () => {
+    test('should call data search with sessionId, isRestore and isStored', async () => {
       tlConfig = {
         ...stubRequestAndServer({ rawResponse: esResponse }),
         request: {
           body: {
-            sessionId: 1,
+            searchSession: {
+              sessionId: '1',
+              isRestore: true,
+              isStored: false,
+            },
           },
         },
       };
 
       await invoke(es, [5], tlConfig);
 
-      expect(tlConfig.context.search.search.mock.calls[0][1]).toHaveProperty('sessionId', 1);
+      const res = tlConfig.context.search.search.mock.calls[0][1];
+      expect(res).toHaveProperty('sessionId', '1');
+      expect(res).toHaveProperty('isRestore', true);
+      expect(res).toHaveProperty('isStored', false);
     });
 
     test('returns a seriesList', () => {

src/plugins/vis_type_timelion/server/series_functions/es/index.js

@@ -133,7 +133,7 @@ export default new Datasource('es', {
       .search(
         body,
         {
-          sessionId: tlConfig.request?.body.sessionId,
+          ...tlConfig.request?.body.searchSession,
         },
         tlConfig.context
       )

src/plugins/vis_type_timeseries/common/vis_schema.ts

@@ -281,5 +281,12 @@ export const visPayloadSchema = schema.object({
     min: stringRequired,
     max: stringRequired,
   }),
-  sessionId: schema.maybe(schema.string()),
+
+  searchSession: schema.maybe(
+    schema.object({
+      sessionId: schema.string(),
+      isRestore: schema.boolean({ defaultValue: false }),
+      isStored: schema.boolean({ defaultValue: false }),
+    })
+  ),
 });