Loki: Decouple from Prometheus operationUtils (#78830)

* Loki: Decouple from Prometheus operationUtils

* Update comments

Author: ivanahuckova

.betterer.results

@@ -5861,6 +5861,9 @@ exports[`better eslint`] = {
       [0, 0, 0, "Styles should be written using objects.", "17"],
       [0, 0, 0, "Styles should be written using objects.", "18"]
     ],
+    "public/app/plugins/datasource/prometheus/querybuilder/operationUtils.ts:5381": [
+      [0, 0, 0, "Do not use any type assertions.", "0"]
+    ],
     "public/app/plugins/datasource/prometheus/querybuilder/shared/LabelFilterItem.tsx:5381": [
       [0, 0, 0, "Use data-testid for E2E selectors instead of aria-label", "0"],
       [0, 0, 0, "Do not use any type assertions.", "1"],
@@ -5889,9 +5892,6 @@ exports[`better eslint`] = {
       [0, 0, 0, "Styles should be written using objects.", "0"],
       [0, 0, 0, "Styles should be written using objects.", "1"]
     ],
-    "public/app/plugins/datasource/prometheus/querybuilder/shared/operationUtils.ts:5381": [
-      [0, 0, 0, "Do not use any type assertions.", "0"]
-    ],
     "public/app/plugins/datasource/prometheus/querybuilder/shared/parsingUtils.ts:5381": [
       [0, 0, 0, "Unexpected any. Specify a different type.", "0"]
     ],

public/app/plugins/datasource/loki/querybuilder/binaryScalarOperations.ts

@@ -1,10 +1,10 @@
-import { defaultAddOperationHandler } from '../../prometheus/querybuilder/shared/operationUtils';
 import {
   QueryBuilderOperation,
   QueryBuilderOperationDef,
   QueryBuilderOperationParamDef,
 } from '../../prometheus/querybuilder/shared/types';
 
+import { defaultAddOperationHandler } from './operationUtils';
 import { LokiOperationId, LokiVisualQueryOperationCategory } from './types';
 
 export const binaryScalarDefs = [

public/app/plugins/datasource/loki/querybuilder/components/UnwrapParamEditor.tsx

@@ -3,13 +3,13 @@ import React, { useState } from 'react';
 import { SelectableValue, getDefaultTimeRange, toOption } from '@grafana/data';
 import { Select } from '@grafana/ui';
 
-import { getOperationParamId } from '../../../prometheus/querybuilder/shared/operationUtils';
 import { QueryBuilderOperationParamEditorProps } from '../../../prometheus/querybuilder/shared/types';
 import { placeHolderScopedVars } from '../../components/monaco-query-field/monaco-completion-provider/validation';
 import { LokiDatasource } from '../../datasource';
 import { getLogQueryFromMetricsQuery, isQueryWithError } from '../../queryUtils';
 import { extractUnwrapLabelKeysFromDataFrame } from '../../responseUtils';
 import { lokiQueryModeller } from '../LokiQueryModeller';
+import { getOperationParamId } from '../operationUtils';
 import { LokiVisualQuery } from '../types';
 
 export function UnwrapParamEditor({

public/app/plugins/datasource/loki/querybuilder/operationUtils.test.ts

@@ -1,6 +1,8 @@
 import { QueryBuilderOperation, QueryBuilderOperationDef } from '../../prometheus/querybuilder/shared/types';
 
 import {
+  createAggregationOperation,
+  createAggregationOperationWithParam,
   createRangeOperation,
   createRangeOperationWithGrouping,
   getLineFilterRenderer,
@@ -322,3 +324,168 @@ describe('pipelineRenderer', () => {
     expect(pipelineRenderer(model, definition!, '{}')).toBe('{} | drop foo, bar, baz');
   });
 });
+
+describe('createAggregationOperation', () => {
+  it('returns correct aggregation definitions with overrides', () => {
+    expect(createAggregationOperation('test_aggregation', { category: 'test_category' })).toMatchObject([
+      {
+        addOperationHandler: {},
+        alternativesKey: 'plain aggregations',
+        category: 'test_category',
+        defaultParams: [],
+        explainHandler: {},
+        id: 'test_aggregation',
+        name: 'Test aggregation',
+        paramChangedHandler: {},
+        params: [
+          {
+            name: 'By label',
+            optional: true,
+            restParam: true,
+            type: 'string',
+          },
+        ],
+        renderer: {},
+      },
+      {
+        alternativesKey: 'aggregations by',
+        category: 'test_category',
+        defaultParams: [''],
+        explainHandler: {},
+        hideFromList: true,
+        id: '__test_aggregation_by',
+        name: 'Test aggregation by',
+        paramChangedHandler: {},
+        params: [
+          {
+            editor: {},
+            name: 'Label',
+            optional: true,
+            restParam: true,
+            type: 'string',
+          },
+        ],
+        renderer: {},
+      },
+      {
+        alternativesKey: 'aggregations by',
+        category: 'test_category',
+        defaultParams: [''],
+        explainHandler: {},
+        hideFromList: true,
+        id: '__test_aggregation_without',
+        name: 'Test aggregation without',
+        paramChangedHandler: {},
+        params: [
+          {
+            name: 'Label',
+            optional: true,
+            restParam: true,
+            type: 'string',
+          },
+        ],
+        renderer: {},
+      },
+    ]);
+  });
+});
+
+describe('createAggregationOperationWithParams', () => {
+  it('returns correct aggregation definitions with overrides and params', () => {
+    expect(
+      createAggregationOperationWithParam(
+        'test_aggregation',
+        {
+          params: [{ name: 'K-value', type: 'number' }],
+          defaultParams: [5],
+        },
+        { category: 'test_category' }
+      )
+    ).toMatchObject([
+      {
+        addOperationHandler: {},
+        alternativesKey: 'plain aggregations',
+        category: 'test_category',
+        defaultParams: [5],
+        explainHandler: {},
+        id: 'test_aggregation',
+        name: 'Test aggregation',
+        paramChangedHandler: {},
+        params: [
+          { name: 'K-value', type: 'number' },
+          { name: 'By label', optional: true, restParam: true, type: 'string' },
+        ],
+        renderer: {},
+      },
+      {
+        alternativesKey: 'aggregations by',
+        category: 'test_category',
+        defaultParams: [5, ''],
+        explainHandler: {},
+        hideFromList: true,
+        id: '__test_aggregation_by',
+        name: 'Test aggregation by',
+        paramChangedHandler: {},
+        params: [
+          { name: 'K-value', type: 'number' },
+          { editor: {}, name: 'Label', optional: true, restParam: true, type: 'string' },
+        ],
+        renderer: {},
+      },
+      {
+        alternativesKey: 'aggregations by',
+        category: 'test_category',
+        defaultParams: [5, ''],
+        explainHandler: {},
+        hideFromList: true,
+        id: '__test_aggregation_without',
+        name: 'Test aggregation without',
+        paramChangedHandler: {},
+        params: [
+          { name: 'K-value', type: 'number' },
+          { name: 'Label', optional: true, restParam: true, type: 'string' },
+        ],
+        renderer: {},
+      },
+    ]);
+  });
+  it('returns correct query string using aggregation definitions with overrides and number type param', () => {
+    const def = createAggregationOperationWithParam(
+      'test_aggregation',
+      {
+        params: [{ name: 'K-value', type: 'number' }],
+        defaultParams: [5],
+      },
+      { category: 'test_category' }
+    );
+
+    const topKByDefinition = def[1];
+    expect(
+      topKByDefinition.renderer(
+        { id: '__topk_by', params: ['5', 'source', 'place'] },
+        def[1],
+        'rate({place="luna"} |= `` [5m])'
+      )
+    ).toBe('test_aggregation by(source, place) (5, rate({place="luna"} |= `` [5m]))');
+  });
+
+  it('returns correct query string using aggregation definitions with overrides and string type param', () => {
+    const def = createAggregationOperationWithParam(
+      'test_aggregation',
+      {
+        params: [{ name: 'Identifier', type: 'string' }],
+        defaultParams: ['count'],
+      },
+      { category: 'test_category' }
+    );
+
+    const countValueDefinition = def[1];
+    expect(
+      countValueDefinition.renderer(
+        { id: 'count_values', params: ['5', 'source', 'place'] },
+        def[1],
+        'rate({place="luna"} |= `` [5m])'
+      )
+    ).toBe('test_aggregation by(source, place) ("5", rate({place="luna"} |= `` [5m]))');
+  });
+});