@finos/legend-query-builder 4.14.20 → 4.14.22

package/src/stores/QueryBuilderResultState.ts

@@ -31,6 +31,7 @@ import {
   type ExecutionResult,
   type RawLambda,
   type EXECUTION_SERIALIZATION_FORMAT,
+  type QueryGridConfig,
   GRAPH_MANAGER_EVENT,
   buildRawLambdaFromLambdaFunction,
   reportGraphAnalytics,
@@ -79,7 +80,9 @@ export interface QueryBuilderTDSResultCellCoordinate {
 
 type QueryBuilderDataGridConfig = {
   columns: DataGridColumnState[];
-  isPivotModeEnabled: boolean;
+  isPivotModeEnabled: boolean | undefined;
+  isLocalModeEnabled: boolean | undefined;
+  previewLimit?: number | undefined;
 };
 
 export class QueryBuilderResultState {
@@ -101,7 +104,7 @@ export class QueryBuilderResultState {
   mousedOverCell: QueryBuilderTDSResultCellData | null = null;
   isSelectingCells: boolean;
 
-  gridConfig!: QueryBuilderDataGridConfig;
+  gridConfig: QueryBuilderDataGridConfig | undefined;
 
   constructor(queryBuilderState: QueryBuilderState) {
     makeObservable(this, {
@@ -128,6 +131,8 @@ export class QueryBuilderResultState {
       setMouseOverCell: action,
       setQueryRunPromise: action,
       setIsQueryUsageViewerOpened: action,
+      handlePreConfiguredGridConfig: action,
+      updatePreviewLimitInConfig: action,
       exportData: flow,
       runQuery: flow,
       cancelQuery: flow,
@@ -136,10 +141,7 @@ export class QueryBuilderResultState {
     this.isSelectingCells = false;
 
     this.selectedCells = [];
-    this.gridConfig = {
-      columns: [],
-      isPivotModeEnabled: false,
-    };
+    this.gridConfig = undefined;
     this.queryBuilderState = queryBuilderState;
     this.executionPlanState = new ExecutionPlanState(
       this.queryBuilderState.applicationStore,
@@ -147,7 +149,7 @@ export class QueryBuilderResultState {
     );
   }
 
-  setGridConfig(val: QueryBuilderDataGridConfig): void {
+  setGridConfig(val: QueryBuilderDataGridConfig | undefined): void {
     this.gridConfig = val;
   }
 
@@ -191,6 +193,33 @@ export class QueryBuilderResultState {
     this.isQueryUsageViewerOpened = val;
   }
 
+  updatePreviewLimitInConfig(): void {
+    if (this.gridConfig) {
+      this.gridConfig.previewLimit = this.previewLimit;
+    }
+  }
+
+  handlePreConfiguredGridConfig(config: QueryGridConfig): void {
+    const newConfig = {
+      ...config,
+      columns: config.columns as DataGridColumnState[],
+    };
+    if (config.previewLimit) {
+      this.setPreviewLimit(config.previewLimit);
+    }
+    this.setGridConfig(newConfig);
+  }
+
+  getQueryGridConfig(): QueryGridConfig | undefined {
+    if (this.gridConfig) {
+      return {
+        ...this.gridConfig,
+        columns: this.gridConfig.columns as object[],
+      };
+    }
+    return undefined;
+  }
+
   get checkForStaleResults(): boolean {
     if (this.latestRunHashCode !== this.queryBuilderState.hashCode) {
       return true;

package/src/stores/QueryBuilderState.ts

@@ -53,6 +53,7 @@ import {
   type GraphManagerState,
   type ValueSpecification,
   type Type,
+  type QueryGridConfig,
   GRAPH_MANAGER_EVENT,
   CompilationError,
   extractSourceInformationCoordinates,
@@ -393,7 +394,10 @@ export abstract class QueryBuilderState implements CommandRegistrar {
     );
   }
 
-  resetQueryResult(options?: { preserveResult?: boolean | undefined }): void {
+  resetQueryResult(options?: {
+    preserveResult?: boolean | undefined;
+    gridConfig?: QueryGridConfig | undefined;
+  }): void {
     const resultState = new QueryBuilderResultState(this);
     resultState.setPreviewLimit(this.resultState.previewLimit);
     if (options?.preserveResult) {
@@ -401,6 +405,10 @@ export abstract class QueryBuilderState implements CommandRegistrar {
       resultState.setExecutionDuration(this.resultState.executionDuration);
       resultState.latestRunHashCode = this.resultState.latestRunHashCode;
     }
+    if (options?.gridConfig) {
+      this.isLocalModeEnabled = true;
+      resultState.handlePreConfiguredGridConfig(options.gridConfig);
+    }
     this.resultState = resultState;
   }
 
@@ -476,6 +484,14 @@ export abstract class QueryBuilderState implements CommandRegistrar {
     return undefined;
   }
 
+  getGridConfig(): QueryGridConfig | undefined {
+    // for now we will only save in local mode
+    if (this.isLocalModeEnabled && this.resultState.gridConfig) {
+      return this.resultState.getQueryGridConfig();
+    }
+    return undefined;
+  }
+
   buildQuery(options?: { keepSourceInformation: boolean }): RawLambda {
     if (!this.isQuerySupported) {
       const parameters = this.parametersState.parameterStates.map((e) =>
@@ -552,11 +568,12 @@ export abstract class QueryBuilderState implements CommandRegistrar {
   initializeWithQuery(
     query: RawLambda,
     defaultParameterValues?: Map<string, ValueSpecification>,
+    gridConfig?: QueryGridConfig,
   ): void {
     this.rebuildWithQuery(query, {
       defaultParameterValues,
     });
-    this.resetQueryResult();
+    this.resetQueryResult({ gridConfig });
     this.changeDetectionState.initialize(query);
     this.changeHistoryState.initialize(query);
   }

package/src/stores/QueryBuilderStateHashUtils.ts

@@ -71,7 +71,7 @@ export enum QUERY_BUILDER_STATE_HASH_STRUCTURE {
   // OLAPGroup state
   TDS_WINDOW_GROUPBY_STATE = 'TDS_WINDOW_STATE',
   TDS_WINDOW_GROUPBY_OPERATION_STATE = 'TDS_WINDOW_OPERATION_STATE',
-  TDS_WINDOW_GROUPBY_AGG_OPERATION_STATE = 'TDS_WINDOW_AGG_OPERATION_STATE',
+  TDS_WINDOW_GROUPBY_AGG_OPERATOR_STATE = 'TDS_WINDOW_AGG_OPERATOR_STATE',
   TDS_WINDOW_COLUMN_STATE = 'TDS_WINDOW_COLUMN_STATE',
   TDS_WINDOW_COLUMN_SORTBY_STATE = 'TDS_WINDOW_COLUMN_SORTBY_STATE',
   TDS_WINDOW_OPERATOR_RANK = 'TDS_WINDOW_OPERATOR_RANK',

package/src/stores/fetch-structure/tds/QueryBuilderTDSState.ts

@@ -278,6 +278,7 @@ export class QueryBuilderTDSState
 
   get fetchStructureValidationIssues(): string[] {
     const validationIssues: string[] = [];
+
     const hasInValidCalendarAggregateColumns =
       this.aggregationState.columns.some(
         (column) =>
@@ -289,6 +290,7 @@ export class QueryBuilderTDSState
         'Query has calendar function with no date column specified',
       );
     }
+
     const hasDuplicatedProjectionColumns = this.projectionColumns.some(
       (column) =>
         this.projectionColumns.filter((c) => c.columnName === column.columnName)
@@ -296,12 +298,23 @@ export class QueryBuilderTDSState
     );
     if (hasDuplicatedProjectionColumns) {
       validationIssues.push('Query has duplicated projection columns');
-      return validationIssues;
     }
-    const hasNoProjectionColumns = this.projectionColumns.length === 0;
+
+    const hasDuplicatedProjectionWindowColumns = this.projectionColumns.some(
+      (column) =>
+        this.windowState.windowColumns.filter(
+          (c) => c.columnName === column.columnName,
+        ).length > 0,
+    );
+    if (hasDuplicatedProjectionWindowColumns) {
+      validationIssues.push('Query has duplicated projection/window columns');
+    }
+
+    const hasNoProjectionColumns =
+      this.projectionColumns.length === 0 &&
+      this.queryBuilderState.changeHistoryState.canUndo;
     if (hasNoProjectionColumns) {
       validationIssues.push('Query has no projection columns');
-      return validationIssues;
     }
     return validationIssues;
   }

package/src/stores/fetch-structure/tds/window/QueryBuilderWindowState.ts

@@ -147,7 +147,7 @@ export class QueryBuilderTDS_WindowAggreationOperatorState extends QueryBuilderT
 
   override get hashCode(): string {
     return hashArray([
-      QUERY_BUILDER_STATE_HASH_STRUCTURE.TDS_WINDOW_GROUPBY_AGG_OPERATION_STATE,
+      QUERY_BUILDER_STATE_HASH_STRUCTURE.TDS_WINDOW_GROUPBY_AGG_OPERATOR_STATE,
       this.lambdaParameterName,
       this.operator,
       this.columnState.columnName,
@@ -162,21 +162,21 @@ export class QueryBuilderWindowColumnState
   readonly windowState: QueryBuilderWindowState;
   windowColumns: QueryBuilderTDSColumnState[] = [];
   sortByState: WindowGroupByColumnSortByState | undefined;
-  operationState: QueryBuilderTDS_WindowOperatorState;
+  operatorState: QueryBuilderTDS_WindowOperatorState;
   columnName: string;
 
   constructor(
     windowState: QueryBuilderWindowState,
     windowColumns: QueryBuilderTDSColumnState[],
     sortType: WindowGroupByColumnSortByState | undefined,
-    operationState: QueryBuilderTDS_WindowOperatorState,
+    operatorState: QueryBuilderTDS_WindowOperatorState,
     columnName: string,
   ) {
     super();
     makeObservable(this, {
       windowColumns: observable,
       sortByState: observable,
-      operationState: observable,
+      operatorState: observable,
       columnName: observable,
       setOperatorState: observable,
       setColumnName: action,
@@ -184,13 +184,14 @@ export class QueryBuilderWindowColumnState
       changeWindow: action,
       deleteWindow: action,
       addWindow: action,
+      setWindows: action,
       changeOperator: action,
       changeSortBy: action,
     });
     this.windowState = windowState;
     this.windowColumns = windowColumns;
     this.sortByState = sortType;
-    this.operationState = operationState;
+    this.operatorState = operatorState;
     this.columnName = columnName;
   }
 
@@ -211,9 +212,9 @@ export class QueryBuilderWindowColumnState
 
   get referencedTDSColumns(): QueryBuilderTDSColumnState[] {
     const operatorReference =
-      this.operationState instanceof
+      this.operatorState instanceof
       QueryBuilderTDS_WindowAggreationOperatorState
-        ? [this.operationState.columnState]
+        ? [this.operatorState.columnState]
         : [];
     const soryByReference = this.sortByState
       ? [this.sortByState.columnState]
@@ -222,7 +223,7 @@ export class QueryBuilderWindowColumnState
   }
 
   getColumnType(): Type | undefined {
-    return this.operationState.operator.getOperatorReturnType(
+    return this.operatorState.operator.getOperatorReturnType(
       this.windowState.tdsState.queryBuilderState.graphManagerState.graph,
     );
   }
@@ -232,7 +233,7 @@ export class QueryBuilderWindowColumnState
   }
 
   setOperatorState(op: QueryBuilderTDS_WindowOperatorState): void {
-    this.operationState = op;
+    this.operatorState = op;
   }
 
   setSortBy(val: WindowGroupByColumnSortByState | undefined): void {
@@ -247,6 +248,10 @@ export class QueryBuilderWindowColumnState
     addUniqueEntry(this.windowColumns, val);
   }
 
+  setWindows(val: QueryBuilderTDSColumnState[]): void {
+    this.windowColumns = val;
+  }
+
   deleteWindow(val: QueryBuilderTDSColumnState): void {
     deleteEntry(this.windowColumns, val);
   }
@@ -262,42 +267,58 @@ export class QueryBuilderWindowColumnState
     return [];
   }
 
-  changeOperator(windowOp: QueryBuilderTDS_WindowOperator): void {
-    const currentOperator = this.operationState.operator;
-    const currentAggregateColumn =
-      this.operationState instanceof
-      QueryBuilderTDS_WindowAggreationOperatorState
-        ? this.operationState.columnState
-        : undefined;
-    if (currentOperator !== windowOp) {
-      if (windowOp.isColumnAggregator()) {
+  getChangeOperatorStateAndColumnName(
+    currentOperator: QueryBuilderTDS_WindowOperator,
+    currentColumn: QueryBuilderTDSColumnState | undefined,
+    newOperator: QueryBuilderTDS_WindowOperator,
+  ):
+    | { operatorState: QueryBuilderTDS_WindowOperatorState; columnName: string }
+    | undefined {
+    if (currentOperator !== newOperator) {
+      if (newOperator.isColumnAggregator()) {
         const compatibleAggCol =
-          currentAggregateColumn &&
-          windowOp.isCompatibleWithColumn(currentAggregateColumn)
-            ? currentAggregateColumn
-            : this.possibleAggregatedColumns(windowOp)[0];
+          currentColumn && newOperator.isCompatibleWithColumn(currentColumn)
+            ? currentColumn
+            : this.possibleAggregatedColumns(newOperator)[0];
         if (compatibleAggCol) {
-          this.setOperatorState(
-            new QueryBuilderTDS_WindowAggreationOperatorState(
+          return {
+            operatorState: new QueryBuilderTDS_WindowAggreationOperatorState(
               this.windowState,
-              windowOp,
+              newOperator,
               compatibleAggCol,
             ),
-          );
-          this.setColumnName(
-            `${windowOp.getLabel()} of ${compatibleAggCol.columnName}`,
-          );
+            columnName: `${newOperator.getLabel()} of ${
+              compatibleAggCol.columnName
+            }`,
+          };
         }
       } else {
-        this.setOperatorState(
-          new QueryBuilderTDS_WindowRankOperatorState(
+        return {
+          operatorState: new QueryBuilderTDS_WindowRankOperatorState(
             this.windowState,
-            windowOp,
+            newOperator,
           ),
-        );
-        this.setColumnName(`${windowOp.getLabel()}`);
+          columnName: `${newOperator.getLabel()}`,
+        };
       }
     }
+    return undefined;
+  }
+
+  changeOperator(windowOp: QueryBuilderTDS_WindowOperator): void {
+    const stateAndName = this.getChangeOperatorStateAndColumnName(
+      this.operatorState.operator,
+      this.operatorState instanceof
+        QueryBuilderTDS_WindowAggreationOperatorState
+        ? this.operatorState.columnState
+        : undefined,
+      windowOp,
+    );
+
+    if (stateAndName) {
+      this.setOperatorState(stateAndName.operatorState);
+      this.setColumnName(stateAndName.columnName);
+    }
   }
 
   changeSortBy(sortOp: COLUMN_SORT_TYPE | undefined): void {
@@ -323,7 +344,7 @@ export class QueryBuilderWindowColumnState
       QUERY_BUILDER_STATE_HASH_STRUCTURE.TDS_WINDOW_COLUMN_STATE,
       hashArray(this.windowColumns),
       this.sortByState ?? '',
-      this.operationState,
+      this.operatorState,
       this.columnName,
     ]);
   }
@@ -362,14 +383,14 @@ export class QueryBuilderWindowState implements Hashable {
     const windowCols = this.windowColumns;
     windowCols.forEach((item, index) => {
       if (
-        item.operationState instanceof
+        item.operatorState instanceof
         QueryBuilderTDS_WindowAggreationOperatorState
       ) {
         if (
-          item.operationState.columnState instanceof
+          item.operatorState.columnState instanceof
           QueryBuilderWindowColumnState
         ) {
-          const windowColumnName = item.operationState.columnState.columnName;
+          const windowColumnName = item.operatorState.columnState.columnName;
           const hasExistingColumn = item.windowState.isColumnOrderValid(
             windowColumnName,
             index,
@@ -403,6 +424,17 @@ export class QueryBuilderWindowState implements Hashable {
     if (hasDuplicatedWindowColumns) {
       issues.push(`Query has duplicated window columns`);
     }
+
+    const hasDuplicatedProjectionWindowColumns = this.windowColumns.some(
+      (column) =>
+        this.tdsState.projectionColumns.filter(
+          (c) => c.columnName === column.columnName,
+        ).length > 0,
+    );
+    if (hasDuplicatedProjectionWindowColumns) {
+      issues.push('Query has duplicated projection/window columns');
+    }
+
     return issues;
   }
 

package/src/stores/fetch-structure/tds/window/QueryBuilderWindowValueSpecificationBuilder.ts

@@ -77,7 +77,7 @@ const appendOLAPGroupByColumnState = (
   }
 
   // create olap operation expression
-  const operationState = olapGroupByColumnState.operationState;
+  const operationState = olapGroupByColumnState.operatorState;
   const olapFunc = extractElementNameFromPath(operationState.operator.pureFunc);
   const olapFuncExpression = new SimpleFunctionExpression(olapFunc);
   olapFuncExpression.parametersValues = [