[feat] Changed the data structure for queries to enable multiple group bys

Author: boristane

CHANGELOG.md

@@ -6,6 +6,8 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ## [Unreleased]
+### Changed
+- Changed the data structure for queries to enable multiple group bys
 
 ## [0.0.68] 2023-05-29
 ### Changed

src/commands/deploy/handlers/validators.ts

@@ -106,18 +106,26 @@ const querySchema = object({
         .default(undefined)
         .noUnknown(true)
         .strict(),
-      groupBy: object({
-        type: string().oneOf(groupByTypes).min(1).required(),
+      groupBys: array()
+        .of(
+          object({
+            type: string().oneOf(groupByTypes).min(1).required(),
+            value: string().min(1).required(),
+          })
+            .noUnknown(true)
+            .strict(),
+        )
+        .optional(),
+      orderBy: object({
         value: string().min(1).required(),
-        orderBy: string().min(1).optional(),
-        limit: number().min(1).optional(),
         order: string().oneOf(["ASC", "DESC"]).optional(),
       })
         .nullable()
         .optional()
         .default(undefined)
         .noUnknown(true)
         .strict(),
+      limit: number().min(1).optional(),
     })
       .noUnknown(true)
       .required()
@@ -350,7 +358,7 @@ function validateQueries(queries: any[] = []) {
       const res = await querySchema.validate(item);
       const filters = res.properties.parameters.filters;
       const calculations = res.properties.parameters.calculations;
-      const groupBy = res.properties.parameters.groupBy;
+      const orderBy = res.properties.parameters.orderBy;
 
       filters?.forEach((filter) => {
         parseFilter(filter);
@@ -364,8 +372,8 @@ function validateQueries(queries: any[] = []) {
         throw new Error("Aliases must me unique across all calculation / visualisation .");
       }
 
-      if (groupBy?.orderBy && !calcs?.some((c) => getCalculationAlias(c) === groupBy?.orderBy)) {
-        throw new Error("The orderBy field of the groupBy must be present in the calculations / visualisations.");
+      if (orderBy?.value && !calcs?.some((c) => getCalculationAlias(c) === orderBy?.value)) {
+        throw new Error("The orderBy must be present in the visualisations.");
       }
     } catch (error) {
       const message = `query: ${item.id}: ${error}`;

src/commands/pull/handlers.ts

@@ -153,7 +153,9 @@ function convertQuery(query: Query): DeploymentQuery {
               matchCase: query.parameters.needle.matchCase,
             }
           : undefined,
-        groupBy: query.parameters.groupBy,
+        groupBys: query.parameters.groupBys,
+        orderBy: query.parameters.orderBy,
+        limit: query.parameters.limit,
         filterCombination: query.parameters.filterCombination,
         filters: query.parameters.filters?.map((filter) => `${filter.key} ${filter.operation} ${filter.value}`),
         calculations: query.parameters.calculations?.map((calculation) => {

src/commands/query/handlers/handlers.ts

@@ -95,9 +95,14 @@ async function interactive(input: { queryId: string; service: string; format: Ou
     // only numeric
     applicableKeys.filter((keySet) => keySet.type === "number"),
   );
-  let groupBy;
+  let groupBys;
+  let orderBy;
+  let limit;
   if (calculations.length) {
-    groupBy = await promptGroupBy(applicableKeys, calculations);
+    const res = await promptGroupBy(applicableKeys, calculations);
+    groupBys = res?.type ? [{ value: res?.value, type: res?.type }] : undefined;
+    orderBy = res?.orderBy ? { value: res?.orderBy, order: res?.order } : undefined;
+    limit = res?.limit ? limit : undefined;
   }
 
   const filters = await promptFilters(applicableKeys);
@@ -121,7 +126,9 @@ async function interactive(input: { queryId: string; service: string; format: Ou
         ...filter,
         operation: filter.operator,
       })),
-      groupBy,
+      groupBys,
+      orderBy,
+      limit,
     },
     config,
   });

src/services/api/paths/queries.ts

@@ -5,7 +5,12 @@ export interface QueryParameters {
   filters?: Array<QueryFilter>;
   filterCombination: "AND" | "OR";
   calculations?: QueryCalculation[];
-  groupBy?: QueryGroupBy;
+  groupBys?: QueryGroupBy[];
+  orderBy?: {
+    value: string;
+    order?: "ASC" | "DESC";
+  };
+  limit?: number;
   needle?: SearchNeedle;
 }
 
@@ -19,9 +24,6 @@ export interface QueryFilter {
 export interface QueryGroupBy {
   type: "string" | "number" | "boolean";
   value: string;
-  orderBy?: string;
-  limit?: number;
-  order?: "ASC" | "DESC";
 }
 
 export interface QueryCalculation {

src/services/api/paths/query-runs.ts

@@ -71,13 +71,12 @@ export interface QueryRunCreateParams {
       isRegex: boolean;
       matchCase: boolean;
     };
-    groupBy?: {
-      limit: number;
-      order: string;
-      orderBy: string;
+    groupBys?: {
       type: string;
       value: string;
-    };
+    }[];
+    orderBy?: { value: string; order: string };
+    limit?: number;
   };
   config: UserConfig;
 }