Code cleaning

* Remove WebAPI leftovers
* Remove leftovers from autocompleters function signature
* Refit autocompleter related types
* It happened (Removed useless branch with `make it happen` comment)
* Fix host tag group autocompleters
* Bumped dependencies

Author: lpetrora

package-lock.json

@@ -6,14 +6,13 @@ import {
   MetricFindValue,
   TestDataSourceResponse,
 } from '@grafana/data';
-import { FetchResponse } from '@grafana/runtime';
 import { EditionFamily, getEditionFamily } from 'edition';
 import { replaceVariables } from 'utils';
 
 import { MetricFindQuery, RequestSpec } from './RequestSpec';
 import RestApiBackend from './backend/rest';
 import { Settings } from './settings';
-import { CmkQuery, DataSourceOptions, Edition, ResponseDataAutocomplete, type WebApiResponse } from './types';
+import { AutocompleterEntry, CmkQuery, DataSourceOptions, Edition } from './types';
 import { AutoCompleteParams } from './ui/autocomplete';
 import { createCmkContext } from './utils';
 
@@ -42,11 +41,8 @@ export class DataSource extends DataSourceApi<CmkQuery> {
     return this.restBackend.testDatasource();
   }
 
-  async autocompleterRequest(
-    api_url: string,
-    data: unknown
-  ): Promise<FetchResponse<WebApiResponse<ResponseDataAutocomplete>>> {
-    return this.restBackend.autocompleterRequest(api_url, data);
+  async autocompleterRequest(data: unknown): Promise<AutocompleterEntry[]> {
+    return this.restBackend.autocompleterRequest(data);
   }
 
   async contextAutocomplete(
@@ -57,15 +53,16 @@ export class DataSource extends DataSourceApi<CmkQuery> {
   ): Promise<Array<{ value: string; label: string; isDisabled: boolean }>> {
     const context = createCmkContext(replaceVariables(partialRequestSpec));
 
-    const response = await this.autocompleterRequest('ajax_vs_autocomplete.py', {
+    const response = await this.autocompleterRequest({
       ident,
       value: prefix,
       params: {
         ...params,
         context,
       },
     });
-    return response.data.result.choices.map(([value, label]: [string, string]) => ({
+
+    return response.map(([value, label]: [string, string]) => ({
       value,
       label,
       isDisabled: value === null,

src/DataSource.ts

@@ -1,26 +1,6 @@
 import { GraphType, NegatableOption, RequestSpec, TagValue } from './RequestSpec';
-import { Context, Edition, Params } from './types';
-import { aggregationToPresentation, createCmkContext, presentationToAggregation } from './utils';
-
-export interface WebApiCurve {
-  title: string;
-  rrddata: Array<{
-    i: number;
-    d: Record<string, unknown>;
-  }>;
-}
-export interface WebAPiGetGraphResult {
-  start_time: number;
-  end_time: number;
-  step: number;
-  curves: WebApiCurve[];
-}
-
-export interface WebApiResponse<Result> {
-  result_code: number;
-  result: Result;
-  severity: string | undefined;
-}
+import { Context, Params } from './types';
+import { presentationToAggregation } from './utils';
 
 function transform_negated(
   context_property: Record<string, string | undefined> | undefined,
@@ -86,69 +66,7 @@ export function requestSpecFromLegacy(context: Context, params: Params): Partial
   }
 
   rs.graph_type = graphModeToGraphType(params.graphMode);
-  if (rs.graph_type === 'single_metric') {
-    rs.graph = params.graph_name;
-  } else {
-    rs.graph = params.graph_name; // TODO: make this happen!
-  }
+  rs.graph = params.graph_name;
   rs.aggregation = presentationToAggregation(params.presentation);
   return rs;
 }
-
-export function createWebApiRequestSpecification(
-  requestSpec: Partial<RequestSpec>,
-  edition: Edition
-): [string, Record<string, unknown>] {
-  if (edition === 'RAW') {
-    const specification: Record<string, unknown> = {};
-    if (requestSpec.graph_type === 'single_metric') {
-      specification.graph_id = 'METRIC_' + requestSpec.graph;
-    } else {
-      specification.graph_name = requestSpec.graph;
-    }
-    return [
-      'template',
-      {
-        site: requestSpec.site,
-        host_name: requestSpec.host_name,
-        service_description: requestSpec.service,
-        ...specification,
-      },
-    ];
-  }
-  const context = createCmkContext(requestSpec);
-  let graph_template: string | undefined = undefined;
-  if (requestSpec.graph && requestSpec.graph !== '') {
-    if (requestSpec.graph_type === 'single_metric') {
-      graph_template = 'METRIC_' + requestSpec.graph;
-    } else {
-      graph_template = requestSpec.graph;
-    }
-  }
-
-  if (requestSpec.aggregation === undefined) {
-    throw new Error('web api: aggregation not defined!');
-  }
-
-  return [
-    'combined',
-    {
-      context: context,
-      datasource: 'services',
-      single_infos: ['host'],
-      graph_template: graph_template,
-      presentation: aggregationToPresentation(requestSpec.aggregation),
-    },
-  ];
-}
-
-export const buildUrlWithParams = (url: string, params: Record<string, string>): string =>
-  url + '?' + new URLSearchParams(params).toString();
-export const buildRequestBody = (data: unknown): string => `request=${JSON.stringify(data)}`;
-
-export function createWebApiRequestBody(context: [string, Record<string, unknown>], timeRange: number[]) {
-  return {
-    specification: context,
-    data_range: { time_range: timeRange },
-  };
-}

src/api_utils.ts

@@ -17,9 +17,8 @@ import { EditionFamily, getEditionFamily, isCloudEdition } from 'edition';
 import { lastValueFrom } from 'rxjs';
 
 import { Aggregation, GraphType, MetricFindQuery } from '../RequestSpec';
-import { CmkQuery, ResponseDataAutocomplete } from '../types';
+import { AutocompleterEntry, CmkQuery } from '../types';
 import { createCmkContext, replaceVariables, toLiveStatusQuery, updateMetricTitles, updateQuery } from '../utils';
-import { type WebApiResponse } from './../types';
 import { Backend, DatasourceOptions } from './types';
 import { validateRequestSpec } from './validate';
 
@@ -375,10 +374,7 @@ export default class RestApiBackend implements Backend {
     }
   }
 
-  async autocompleterRequest(
-    api_url = '',
-    data: unknown
-  ): Promise<FetchResponse<WebApiResponse<ResponseDataAutocomplete>>> {
+  async autocompleterRequest(data: unknown): Promise<AutocompleterEntry[]> {
     const { ident, params: parameters, value } = data as { ident: string; value: unknown; params: unknown };
 
     const response = await this.api<RestApiAutocompleteResponse>({
@@ -389,15 +385,6 @@ export default class RestApiBackend implements Backend {
 
     const choices = response?.data?.choices || [];
 
-    const new_data: WebApiResponse<ResponseDataAutocomplete> = {
-      result_code: 200,
-      severity: 'success',
-      result: {
-        choices: choices.map((element) => [element.id, element.value]),
-      },
-    };
-
-    const res: FetchResponse<WebApiResponse<ResponseDataAutocomplete>> = { ...response, data: new_data };
-    return res;
+    return choices.map((element) => [element.id, element.value]);
   }
 }

src/backend/rest.ts

@@ -75,9 +75,9 @@ export interface DataSourceOptions extends DataSourceJsonData {
 export interface SecureJsonData {
   secret?: string;
 }
-
+export type AutocompleterEntry = [string, string];
 export interface ResponseDataAutocomplete {
-  choices: Array<[string, string]>;
+  choices: AutocompleterEntry[];
 }
 
 export enum LabelVariableNames {
@@ -88,9 +88,3 @@ export enum LabelVariableNames {
   SERVICE = '$filter_service',
   SERVICE_IN_GROUP = '$filter_service_in_group',
 }
-
-export interface WebApiResponse<Result> {
-  result_code: number;
-  result: Result;
-  severity: string | undefined;
-}

src/types.ts

@@ -1,3 +1,4 @@
+import { SelectableValue } from '@grafana/data';
 import React from 'react';
 
 import { DataSource } from '../DataSource';
@@ -72,22 +73,27 @@ export const Filters = (props: FiltersProp): React.JSX.Element => {
     [datasource, qSite]
   );
   const hostTagAutocompleter = React.useCallback(
-    (prefix: string, mode: 'groups' | 'choices', context: Record<string, unknown>) => {
+    async (
+      prefix: string,
+      mode: 'groups' | 'choices',
+      context: Record<string, unknown>
+    ): Promise<Array<SelectableValue<string>>> => {
       if (mode === 'groups') {
-        return datasource.contextAutocomplete('tag_groups', { site: qSite, ...context }, prefix, { strict: true });
+        return await datasource.contextAutocomplete('tag_groups', { site: qSite, ...context }, prefix, {
+          strict: true,
+        });
       } else {
-        return (async function () {
-          // TODO: would have expected that this is dependent on the site, but does not look like that?
-          const response = await datasource.autocompleterRequest('ajax_vs_autocomplete.py', {
-            ident: 'tag_groups_opt',
-            params: { group_id: context.groupId, strict: true },
-            value: prefix,
-          });
-          return response.data.result.choices.map(([value, label]: [string, string]) => ({
-            value,
-            label,
-          }));
-        })();
+        const options = await datasource.autocompleterRequest({
+          ident: 'tag_groups_opt',
+          params: { group_id: context.groupId, strict: true },
+          value: prefix,
+        });
+
+        return options.map(([value, label]: [string, string]) => ({
+          value,
+          label,
+          isDisabled: value === null,
+        }));
       }
     },
     [datasource, qSite]

src/ui/filters.tsx

@@ -3,7 +3,7 @@ import { getTemplateSrv } from '@grafana/runtime';
 import { isUndefined } from 'lodash';
 
 import { Aggregation, FiltersRequestSpec, NegatableOption, RequestSpec, TagValue } from './RequestSpec';
-import { WebApiCurve, requestSpecFromLegacy } from './api_utils';
+import { requestSpecFromLegacy } from './api_utils';
 import { MetricResponse } from './backend/rest';
 import { CmkQuery, LabelVariableNames } from './types';
 import { Presentation } from './ui/autocomplete';
@@ -261,7 +261,7 @@ export function toLiveStatusQuery(filter: Partial<FiltersRequestSpec>, table: 'h
   };
 }
 
-type GrapResponse = WebApiCurve | MetricResponse;
+type GrapResponse = MetricResponse;
 
 export function updateMetricTitles(metrics: GrapResponse[], query: CmkQuery, scopedVars: ScopedVars = {}) {
   const titleTemplate = query.requestSpec?.label || LabelVariableNames.ORIGINAL;

src/utils.ts

@@ -4,23 +4,13 @@ import { cloneDeep } from 'lodash';
 
 import { DataSource } from '../../src/DataSource';
 import { RequestSpec } from '../../src/RequestSpec';
-import { buildRequestBody, buildUrlWithParams } from '../../src/api_utils';
 import RestApiBackend from '../../src/backend/rest';
 import { CmkQuery, DataSourceOptions, Edition } from '../../src/types';
 import { labelForRequestSpecKey } from '../../src/ui/utils';
 import * as utils from '../../src/utils';
 
 jest.mock('../../src/utils');
 
-describe('URL conversions', () => {
-  it('Params', () => {
-    expect(buildUrlWithParams('hi', { A: '5', TE: 'TTI' })).toBe('hi?A=5&TE=TTI');
-  });
-  it('Request body', () => {
-    expect(buildRequestBody({ spec: ['comb', { site: 'heute' }] })).toBe('request={"spec":["comb",{"site":"heute"}]}');
-  });
-});
-
 // from https://stackoverflow.com/questions/42773836/how-to-find-all-subsets-of-a-set-in-javascript-powerset-of-array
 const allSubsets = (values: string[]): string[][] =>
   values.reduce((subsets, value) => subsets.concat(subsets.map((set) => [value, ...set])), [[]]);