[TSVB] use new Search API for rollup search

.github/CODEOWNERS

@@ -9,6 +9,7 @@
 /x-pack/plugins/discover_enhanced/ @elastic/kibana-app
 /x-pack/plugins/lens/ @elastic/kibana-app
 /x-pack/plugins/graph/ @elastic/kibana-app
+/x-pack/plugins/vis_type_timeseries_enhanced/ @elastic/kibana-app
 /src/plugins/advanced_settings/ @elastic/kibana-app
 /src/plugins/charts/ @elastic/kibana-app
 /src/plugins/discover/ @elastic/kibana-app

docs/developer/plugin-list.asciidoc

@@ -554,6 +554,10 @@ in their infrastructure.
 |NOTE: This plugin contains implementation of URL drilldown. For drilldowns infrastructure code refer to ui_actions_enhanced plugin.
 
 
+|{kib-repo}blob/{branch}/x-pack/plugins/vis_type_timeseries_enhanced/README.md[visTypeTimeseriesEnhanced]
+|The vis_type_timeseries_enhanced plugin is the x-pack counterpart to the OSS vis_type_timeseries plugin.
+
+
 |{kib-repo}blob/{branch}/x-pack/plugins/watcher/README.md[watcher]
 |This plugins adopts some conventions in addition to or in place of conventions in Kibana (at the time of the plugin's creation):
 

src/plugins/vis_type_timeseries/server/index.ts

@@ -43,7 +43,9 @@ export {
   AbstractSearchStrategy,
   ReqFacade,
 } from './lib/search_strategies/strategies/abstract_search_strategy';
-// @ts-ignore
+
+export { VisPayload } from '../common/types';
+
 export { DefaultSearchCapabilities } from './lib/search_strategies/default_search_capabilities';
 
 export function plugin(initializerContext: PluginInitializerContext) {

src/plugins/vis_type_timeseries/server/lib/get_fields.ts

@@ -38,7 +38,7 @@ export async function getFields(
   // removes the need to refactor many layers of dependencies on "req", and instead just augments the top
   // level object passed from here. The layers should be refactored fully at some point, but for now
   // this works and we are still using the New Platform services for these vis data portions.
-  const reqFacade: ReqFacade = {
+  const reqFacade: ReqFacade<{}> = {
     requestContext,
     ...request,
     framework,

src/plugins/vis_type_timeseries/server/lib/get_vis_data.ts

@@ -64,7 +64,7 @@ export function getVisData(
   // removes the need to refactor many layers of dependencies on "req", and instead just augments the top
   // level object passed from here. The layers should be refactored fully at some point, but for now
   // this works and we are still using the New Platform services for these vis data portions.
-  const reqFacade: ReqFacade = {
+  const reqFacade: ReqFacade<GetVisDataOptions> = {
     requestContext,
     ...request,
     framework,

src/plugins/vis_type_timeseries/server/lib/search_strategies/default_search_capabilities.test.js → src/plugins/vis_type_timeseries/server/lib/search_strategies/default_search_capabilities.test.ts

@@ -17,13 +17,15 @@
  * under the License.
  */
 import { DefaultSearchCapabilities } from './default_search_capabilities';
+import { ReqFacade } from './strategies/abstract_search_strategy';
+import { VisPayload } from '../../../common/types';
 
 describe('DefaultSearchCapabilities', () => {
-  let defaultSearchCapabilities;
-  let req;
+  let defaultSearchCapabilities: DefaultSearchCapabilities;
+  let req: ReqFacade<VisPayload>;
 
   beforeEach(() => {
-    req = {};
+    req = {} as ReqFacade<VisPayload>;
     defaultSearchCapabilities = new DefaultSearchCapabilities(req);
   });
 
@@ -45,13 +47,13 @@ describe('DefaultSearchCapabilities', () => {
   });
 
   test('should return Search Timezone', () => {
-    defaultSearchCapabilities.request = {
+    defaultSearchCapabilities.request = ({
       payload: {
         timerange: {
           timezone: 'UTC',
         },
       },
-    };
+    } as unknown) as ReqFacade<VisPayload>;
 
     expect(defaultSearchCapabilities.searchTimezone).toEqual('UTC');
   });

src/plugins/vis_type_timeseries/server/lib/search_strategies/default_search_capabilities.js → src/plugins/vis_type_timeseries/server/lib/search_strategies/default_search_capabilities.ts

@@ -16,77 +16,80 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+import { Unit } from '@elastic/datemath';
 import {
   convertIntervalToUnit,
   parseInterval,
   getSuitableUnit,
 } from '../vis_data/helpers/unit_to_seconds';
 import { RESTRICTIONS_KEYS } from '../../../common/ui_restrictions';
+import { ReqFacade } from './strategies/abstract_search_strategy';
+import { VisPayload } from '../../../common/types';
 
-const getTimezoneFromRequest = (request) => {
+const getTimezoneFromRequest = (request: ReqFacade<VisPayload>) => {
   return request.payload.timerange.timezone;
 };
 
 export class DefaultSearchCapabilities {
-  constructor(request, fieldsCapabilities = {}) {
-    this.request = request;
-    this.fieldsCapabilities = fieldsCapabilities;
-  }
+  constructor(
+    public request: ReqFacade<VisPayload>,
+    public fieldsCapabilities: Record<string, any> = {}
+  ) {}
 
-  get defaultTimeInterval() {
+  public get defaultTimeInterval() {
     return null;
   }
 
-  get whiteListedMetrics() {
+  public get whiteListedMetrics() {
     return this.createUiRestriction();
   }
 
-  get whiteListedGroupByFields() {
+  public get whiteListedGroupByFields() {
     return this.createUiRestriction();
   }
 
-  get whiteListedTimerangeModes() {
+  public get whiteListedTimerangeModes() {
     return this.createUiRestriction();
   }
 
-  get uiRestrictions() {
+  public get uiRestrictions() {
     return {
       [RESTRICTIONS_KEYS.WHITE_LISTED_METRICS]: this.whiteListedMetrics,
       [RESTRICTIONS_KEYS.WHITE_LISTED_GROUP_BY_FIELDS]: this.whiteListedGroupByFields,
       [RESTRICTIONS_KEYS.WHITE_LISTED_TIMERANGE_MODES]: this.whiteListedTimerangeModes,
     };
   }
 
-  get searchTimezone() {
+  public get searchTimezone() {
     return getTimezoneFromRequest(this.request);
   }
 
-  createUiRestriction(restrictionsObject) {
+  createUiRestriction(restrictionsObject?: Record<string, any>) {
     return {
       '*': !restrictionsObject,
       ...(restrictionsObject || {}),
     };
   }
 
-  parseInterval(interval) {
+  parseInterval(interval: string) {
     return parseInterval(interval);
   }
 
-  getSuitableUnit(intervalInSeconds) {
+  getSuitableUnit(intervalInSeconds: string | number) {
     return getSuitableUnit(intervalInSeconds);
   }
 
-  convertIntervalToUnit(intervalString, unit) {
+  convertIntervalToUnit(intervalString: string, unit: Unit) {
     const parsedInterval = this.parseInterval(intervalString);
 
-    if (parsedInterval.unit !== unit) {
+    if (parsedInterval?.unit !== unit) {
       return convertIntervalToUnit(intervalString, unit);
     }
 
     return parsedInterval;
   }
 
-  getValidTimeInterval(intervalString) {
+  getValidTimeInterval(intervalString: string) {
     // Default search capabilities doesn't have any restrictions for the interval string
     return intervalString;
   }

src/plugins/vis_type_timeseries/server/lib/search_strategies/search_strategies_registry.test.ts

@@ -27,10 +27,10 @@ import { DefaultSearchCapabilities } from './default_search_capabilities';
 
 class MockSearchStrategy extends AbstractSearchStrategy {
   checkForViability() {
-    return {
+    return Promise.resolve({
       isViable: true,
       capabilities: {},
-    };
+    });
   }
 }
 
@@ -65,7 +65,7 @@ describe('SearchStrategyRegister', () => {
   });
 
   test('should add a strategy if it is an instance of AbstractSearchStrategy', () => {
-    const anotherSearchStrategy = new MockSearchStrategy('es');
+    const anotherSearchStrategy = new MockSearchStrategy();
     const addedStrategies = registry.addStrategy(anotherSearchStrategy);
 
     expect(addedStrategies.length).toEqual(2);
@@ -75,7 +75,7 @@ describe('SearchStrategyRegister', () => {
   test('should return a MockSearchStrategy instance', async () => {
     const req = {};
     const indexPattern = '*';
-    const anotherSearchStrategy = new MockSearchStrategy('es');
+    const anotherSearchStrategy = new MockSearchStrategy();
     registry.addStrategy(anotherSearchStrategy);
 
     const { searchStrategy, capabilities } = (await registry.getViableStrategy(req, indexPattern))!;

src/plugins/vis_type_timeseries/server/lib/search_strategies/strategies/abstract_search_strategy.ts

@@ -46,16 +46,8 @@ export interface ReqFacade<T = unknown> extends FakeRequest {
   getEsShardTimeout: () => Promise<number>;
 }
 
-export class AbstractSearchStrategy {
-  public indexType?: string;
-  public additionalParams: any;
-
-  constructor(type?: string, additionalParams: any = {}) {
-    this.indexType = type;
-    this.additionalParams = additionalParams;
-  }
-
-  async search(req: ReqFacade<VisPayload>, bodies: any[], options = {}) {
+export abstract class AbstractSearchStrategy {
+  async search(req: ReqFacade<VisPayload>, bodies: any[], indexType?: string) {
     const requests: any[] = [];
     const { sessionId } = req.payload;
 
@@ -64,15 +56,13 @@ export class AbstractSearchStrategy {
         req.requestContext
           .search!.search(
             {
+              indexType,
               params: {
                 ...body,
-                ...this.additionalParams,
               },
-              indexType: this.indexType,
             },
             {
               sessionId,
-              ...options,
             }
           )
           .toPromise()
@@ -81,19 +71,23 @@ export class AbstractSearchStrategy {
     return Promise.all(requests);
   }
 
-  async getFieldsForWildcard(req: ReqFacade, indexPattern: string, capabilities: any) {
+  checkForViability(
+    req: ReqFacade<VisPayload>,
+    indexPattern: string
+  ): Promise<{ isViable: boolean; capabilities: unknown }> {
+    throw new TypeError('Must override method');
+  }
+
+  async getFieldsForWildcard<TPayload = unknown>(
+    req: ReqFacade<TPayload>,
+    indexPattern: string,
+    capabilities?: unknown
+  ) {
     const { indexPatternsService } = req.pre;
 
     return await indexPatternsService!.getFieldsForWildcard({
       pattern: indexPattern,
       fieldCapsOptions: { allow_no_indices: true },
     });
   }
-
-  checkForViability(
-    req: ReqFacade,
-    indexPattern: string
-  ): { isViable: boolean; capabilities: any } {
-    throw new TypeError('Must override method');
-  }
 }

src/plugins/vis_type_timeseries/server/lib/search_strategies/strategies/default_search_strategy.test.js → src/plugins/vis_type_timeseries/server/lib/search_strategies/strategies/default_search_strategy.test.ts

@@ -17,13 +17,15 @@
  * under the License.
  */
 import { DefaultSearchStrategy } from './default_search_strategy';
+import { ReqFacade } from './abstract_search_strategy';
+import { VisPayload } from '../../../../common/types';
 
 describe('DefaultSearchStrategy', () => {
-  let defaultSearchStrategy;
-  let req;
+  let defaultSearchStrategy: DefaultSearchStrategy;
+  let req: ReqFacade<VisPayload>;
 
   beforeEach(() => {
-    req = {};
+    req = {} as ReqFacade<VisPayload>;
     defaultSearchStrategy = new DefaultSearchStrategy();
   });
 
@@ -34,8 +36,8 @@ describe('DefaultSearchStrategy', () => {
     expect(defaultSearchStrategy.getFieldsForWildcard).toBeDefined();
   });
 
-  test('should check a strategy for viability', () => {
-    const value = defaultSearchStrategy.checkForViability(req);
+  test('should check a strategy for viability', async () => {
+    const value = await defaultSearchStrategy.checkForViability(req);
 
     expect(value.isViable).toBe(true);
     expect(value.capabilities).toEqual({

src/plugins/vis_type_timeseries/server/lib/search_strategies/strategies/default_search_strategy.js → src/plugins/vis_type_timeseries/server/lib/search_strategies/strategies/default_search_strategy.ts

@@ -17,16 +17,17 @@
  * under the License.
  */
 
-import { AbstractSearchStrategy } from './abstract_search_strategy';
+import { AbstractSearchStrategy, ReqFacade } from './abstract_search_strategy';
 import { DefaultSearchCapabilities } from '../default_search_capabilities';
+import { VisPayload } from '../../../../common/types';
 
 export class DefaultSearchStrategy extends AbstractSearchStrategy {
   name = 'default';
 
-  checkForViability(req) {
-    return {
+  checkForViability(req: ReqFacade<VisPayload>) {
+    return Promise.resolve({
       isViable: true,
       capabilities: new DefaultSearchCapabilities(req),
-    };
+    });
   }
 }

src/plugins/vis_type_timeseries/server/lib/vis_data/helpers/get_bucket_size.js

@@ -42,14 +42,18 @@ const calculateBucketData = (timeInterval, capabilities) => {
   }
 
   // Check decimal
-  if (parsedInterval.value % 1 !== 0) {
+  if (parsedInterval && parsedInterval.value % 1 !== 0) {
     if (parsedInterval.unit !== 'ms') {
-      const { value, unit } = convertIntervalToUnit(
+      const converted = convertIntervalToUnit(
         intervalString,
         ASCENDING_UNIT_ORDER[ASCENDING_UNIT_ORDER.indexOf(parsedInterval.unit) - 1]
       );
 
-      intervalString = value + unit;
+      if (converted) {
+        intervalString = converted.value + converted.unit;
+      }
+
+      intervalString = undefined;
     } else {
       intervalString = '1ms';
     }