Resolve some explicit anys

Author: BenediktSeidl

src/DataSource.ts

@@ -8,15 +8,15 @@ import {
   MutableDataFrame,
   FieldType,
 } from '@grafana/data';
-import { getBackendSrv } from '@grafana/runtime';
+import { FetchResponse, getBackendSrv, BackendSrvRequest } from '@grafana/runtime';
 
 import { buildRequestBody, combinedDesc, graphDefinitionRequest } from './graphspecs';
-import { MyQuery, defaultQuery, MyDataSourceOptions } from './types';
+import { MyQuery, defaultQuery, MyDataSourceOptions, ResponseData, ResponseDataCurves } from './types';
 
 export const buildUrlWithParams = (url: string, params: Record<string, string>) =>
   url + '?' + new URLSearchParams(params).toString();
 
-function buildMetricDataFrame(response: any, query: MyQuery) {
+function buildMetricDataFrame(response: FetchResponse<ResponseData<ResponseDataCurves>>, query: MyQuery) {
   if (response.data.result_code !== 0) {
     throw new Error(`${response.data.result}`);
   }
@@ -25,12 +25,10 @@ function buildMetricDataFrame(response: any, query: MyQuery) {
   const frame = new MutableDataFrame({
     refId: query.refId,
     fields: [{ name: 'Time', type: FieldType.time }].concat(
-      curves.map((x: any) => ({ name: x.title, type: FieldType.number }))
+      curves.map((x) => ({ name: x.title, type: FieldType.number }))
     ),
   });
-  zip(...curves.map((x: any) => x.rrddata)).forEach((d: any, i: number) =>
-    frame.appendRow([(start_time + i * step) * 1000, ...d])
-  );
+  zip(...curves.map((x) => x.rrddata)).forEach((d, i) => frame.appendRow([(start_time + i * step) * 1000, ...d]));
   return frame;
 }
 
@@ -56,7 +54,7 @@ export class DataSource extends DataSourceApi<MyQuery> {
       return new MutableDataFrame();
     }
     const editionMode = get(this, 'instanceSettings.jsonData.edition', 'CEE');
-    const response = await this.doRequest({
+    const response = await this.doRequest<ResponseDataCurves>({
       ...query,
       params: { action: 'get_graph' },
       data: graphDefinitionRequest(editionMode, query, range),
@@ -93,27 +91,27 @@ export class DataSource extends DataSourceApi<MyQuery> {
       });
   }
 
-  async doRequest(options: MyQuery) {
-    return this.cmkRequest({
+  async doRequest<T>(options: MyQuery): Promise<FetchResponse<ResponseData<T>>> {
+    return this.cmkRequest<T>({
       method: options.data == null ? 'GET' : 'POST',
       headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
       url: buildUrlWithParams(`${this.instanceSettings.url}/cmk/check_mk/webapi.py`, { ...options.params }),
       data: options.data,
     });
   }
 
-  async restRequest(api_url: string, data: any) {
-    return this.cmkRequest({
+  async restRequest<T>(api_url: string, data: any): Promise<FetchResponse<ResponseData<T>>> {
+    return this.cmkRequest<T>({
       method: 'POST',
       headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
       url: `${this.instanceSettings.url}/cmk/check_mk/${api_url}`,
       data: buildRequestBody(data),
     });
   }
 
-  async cmkRequest(request: any) {
+  async cmkRequest<T>(request: BackendSrvRequest): Promise<FetchResponse<ResponseData<T>>> {
     const result = await getBackendSrv()
-      .fetch<{ result_code: number, result: any}>(request)
+      .fetch<ResponseData<T>>(request)
       .toPromise()
       .catch((error) => {
         if (error.cancelled) {
@@ -126,7 +124,7 @@ export class DataSource extends DataSourceApi<MyQuery> {
       });
 
     if (result === undefined) {
-      return undefined;
+      throw new Error('Got undefined result');
     }
 
     if (result.data instanceof String) {

src/components/fields.tsx

@@ -5,7 +5,7 @@ import { AutoCompleteEditorProps, AutoCompleteConfig, EditorProps } from './type
 import { get, update as _update, cloneDeep } from 'lodash';
 import { DataSource } from '../DataSource';
 import { combinedDesc } from 'graphspecs';
-import { MyQuery } from 'types';
+import { MyQuery, ResponseDataAutocomplete } from 'types';
 
 const update = (x: MyQuery, path: string, func: () => SelectableValue<string> | string | undefined) => {
   const copy = cloneDeep(x);
@@ -16,7 +16,7 @@ const update = (x: MyQuery, path: string, func: () => SelectableValue<string> |
 export const vsAutocomplete =
   (datasource: DataSource, autocompleteConfig: AutoCompleteConfig) => (inputValue: string) =>
     datasource
-      .restRequest('ajax_vs_autocomplete.py', {
+      .restRequest<ResponseDataAutocomplete>('ajax_vs_autocomplete.py', {
         ...autocompleteConfig,
         value: inputValue.trim(),
       })

src/components/filters.tsx

@@ -14,6 +14,7 @@ import { SelectableValue } from '@grafana/data';
 import { EditorProps } from './types';
 import { AsyncAutocomplete, vsAutocomplete } from './fields';
 import { get, update } from 'lodash';
+import { ResponseDataAutocompleteLabel } from 'types';
 
 export const SiteFilter = (props: EditorProps) => {
   const sitesVS = { ident: 'sites', params: { strict: false, context: props.query.context } };
@@ -117,7 +118,7 @@ export const HostLabelsFilter = ({ datasource, onChange, query, onRunQuery }: Ed
   const getHostLabels = (inputValue: string) => {
     const search = inputValue.trim().toLowerCase();
     return datasource
-      .restRequest('ajax_autocomplete_labels.py', {
+      .restRequest<ResponseDataAutocompleteLabel>('ajax_autocomplete_labels.py', {
         world: 'core',
         search_label: search,
       })

src/types.ts

@@ -46,3 +46,29 @@ export interface MyDataSourceOptions extends DataSourceJsonData {
 export interface MySecureJsonData {
   secret?: string;
 }
+
+export interface ResponseDataAutocomplete {
+  choices: [string, string][];
+}
+
+export type ResponseDataAutocompleteLabel = {
+  value: string;
+}[];
+
+export interface ResponseDataCurves {
+  filter: unknown;
+  start_time: number;
+  step: number;
+  curves: {
+    title: string;
+    rrddata: {
+      i: number;
+      d: Record<string, unknown>;
+    }[];
+  }[];
+}
+
+export interface ResponseData<T> {
+  result_code: number;
+  result: T;
+}