@finos/legend-query-builder 4.10.0 → 4.10.1

package/src/components/QueryBuilderResultPanel.tsx

@@ -52,7 +52,6 @@ import {
   EnumValueInstanceValue,
   EnumValueExplicitReference,
   RelationalExecutionActivities,
-  getTDSRowRankByColumnInAsc,
 } from '@finos/legend-graph';
 import {
   ActionAlertActionType,
@@ -63,8 +62,6 @@ import {
 import {
   assertErrorThrown,
   guaranteeNonNullable,
-  isBoolean,
-  type PlainObject,
   prettyDuration,
   filterByType,
   isValidURL,
@@ -420,9 +417,7 @@ const QueryBuilderGridResultContextMenu = observer(
       ),
     );
 
-    const findRowFromRowIndex = (
-      rowIndex: number,
-    ): (string | number | boolean | null)[] => {
+    const findSelectedCellRowData = (): string => {
       if (
         !tdsState.queryBuilderState.resultState.executionResult ||
         !(
@@ -430,21 +425,31 @@ const QueryBuilderGridResultContextMenu = observer(
           TDSExecutionResult
         )
       ) {
-        return [''];
+        return '';
       }
-      return (
-        tdsState.queryBuilderState.resultState.executionResult.result.rows[
-          rowIndex
-        ]?.values ?? ['']
+      const rowData = tdsState.queryBuilderState.resultState.rowData.find(
+        (rData) =>
+          rData.rowNumber ===
+          tdsState.queryBuilderState.resultState.selectedCells[0]?.coordinates
+            .rowIndex,
       );
+      // try to get the entire row value separated by comma
+      // rowData is in format of {columnName: value, columnName1: value, ...., rowNumber:value}
+      const valueArr: (string | number | boolean | null | undefined)[] = [];
+      if (rowData) {
+        Object.entries(rowData).forEach((entry) => {
+          if (entry[0] !== 'rowNumber') {
+            valueArr.push(entry[1]);
+          }
+        });
+        return valueArr.join(',');
+      }
+      return '';
     };
 
     const handleCopyRowValue = applicationStore.guardUnhandledError(() =>
       applicationStore.clipboardService.copyTextToClipboard(
-        findRowFromRowIndex(
-          tdsState.queryBuilderState.resultState.selectedCells[0]?.coordinates
-            .rowIndex ?? 0,
-        ).toString(),
+        findSelectedCellRowData(),
       ),
     );
 
@@ -502,18 +507,18 @@ const QueryResultCellRenderer = observer(
       isString(cellValue) && isValidURL(cellValue) ? cellValue : undefined;
     const columnName = params.column?.getColId() ?? '';
     const findCoordinatesFromResultValue = (
-      colId: string,
+      colName: string,
       rowNumber: number,
     ): QueryBuilderTDSResultCellCoordinate => {
       const colIndex = tdsExecutionResult.result.columns.findIndex(
-        (col) => col === colId,
+        (col) => col === colName,
       );
       return { rowIndex: rowNumber, colIndex: colIndex };
     };
 
     const currentCellCoordinates = findCoordinatesFromResultValue(
       columnName,
-      params.rowIndex,
+      params.data.rowNumber,
     );
     const cellInFilteredResults = resultState.selectedCells.some(
       (result) =>
@@ -521,9 +526,9 @@ const QueryResultCellRenderer = observer(
         result.coordinates.rowIndex === currentCellCoordinates.rowIndex,
     );
 
-    const findColumnFromCoordinates = (
+    const findColumnNameFromColumnIndex = (
       colIndex: number,
-    ): string | number | boolean | null | undefined => {
+    ): string | undefined => {
       if (
         !resultState.executionResult ||
         !(resultState.executionResult instanceof TDSExecutionResult)
@@ -534,30 +539,12 @@ const QueryResultCellRenderer = observer(
     };
 
     const findResultValueFromCoordinates = (
-      resultCoordinate: [number, number],
-    ): string | number | boolean | null | undefined => {
-      const rowIndex = resultCoordinate[0];
-      const colIndex = resultCoordinate[1];
-
-      if (
-        !resultState.executionResult ||
-        !(resultState.executionResult instanceof TDSExecutionResult)
-      ) {
-        return undefined;
-      }
-      if (params.columnApi.getColumnState()[colIndex]?.sort === 'asc') {
-        resultState.executionResult.result.rows.sort((a, b) =>
-          getTDSRowRankByColumnInAsc(a, b, colIndex),
-        );
-      } else if (params.columnApi.getColumnState()[colIndex]?.sort === 'desc') {
-        resultState.executionResult.result.rows.sort((a, b) =>
-          getTDSRowRankByColumnInAsc(b, a, colIndex),
-        );
-      }
-      return resultState.executionResult.result.rows[rowIndex]?.values[
-        colIndex
-      ];
-    };
+      rowIndex: number,
+      colName: string,
+    ): string | number | boolean | null | undefined =>
+      resultState.rowData.find((data) => data.rowNumber === rowIndex)![
+        colName
+      ] as string | number | boolean | null | undefined;
 
     const isCoordinatesSelected = (
       resultCoordinate: QueryBuilderTDSResultCellCoordinate,
@@ -574,12 +561,12 @@ const QueryResultCellRenderer = observer(
       if (event.shiftKey) {
         const coordinates = findCoordinatesFromResultValue(
           columnName,
-          params.rowIndex,
+          params.data.rowNumber,
         );
-        const actualValue = findResultValueFromCoordinates([
+        const actualValue = findResultValueFromCoordinates(
           coordinates.rowIndex,
-          coordinates.colIndex,
-        ]);
+          columnName,
+        );
         resultState.addSelectedCell({
           value: actualValue,
           columnName: columnName,
@@ -593,12 +580,12 @@ const QueryResultCellRenderer = observer(
         resultState.setSelectedCells([]);
         const coordinates = findCoordinatesFromResultValue(
           columnName,
-          params.rowIndex,
+          params.data.rowNumber,
         );
-        const actualValue = findResultValueFromCoordinates([
+        const actualValue = findResultValueFromCoordinates(
           coordinates.rowIndex,
-          coordinates.colIndex,
-        ]);
+          columnName,
+        );
         resultState.setSelectedCells([
           {
             value: actualValue,
@@ -612,14 +599,14 @@ const QueryResultCellRenderer = observer(
       if (event.button === 2) {
         const coordinates = findCoordinatesFromResultValue(
           columnName,
-          params.rowIndex,
+          params.data.rowNumber,
         );
         const isInSelected = isCoordinatesSelected(coordinates);
         if (!isInSelected) {
-          const actualValue = findResultValueFromCoordinates([
+          const actualValue = findResultValueFromCoordinates(
             coordinates.rowIndex,
-            coordinates.colIndex,
-          ]);
+            columnName,
+          );
           resultState.setSelectedCells([
             {
               value: actualValue,
@@ -649,7 +636,7 @@ const QueryResultCellRenderer = observer(
         const firstCorner = results.coordinates;
         const secondCorner = findCoordinatesFromResultValue(
           columnName,
-          params.rowIndex,
+          params.data.rowNumber,
         );
 
         resultState.setSelectedCells([results]);
@@ -661,11 +648,13 @@ const QueryResultCellRenderer = observer(
 
         for (let x = minRow; x <= maxRow; x++) {
           for (let y = minCol; y <= maxCol; y++) {
-            const actualValue = findResultValueFromCoordinates([x, y]);
-
+            const actualValue = findResultValueFromCoordinates(
+              x,
+              findColumnNameFromColumnIndex(y) as string,
+            );
             const valueAndColumnId = {
               value: actualValue,
-              columnName: findColumnFromCoordinates(y),
+              columnName: findColumnNameFromColumnIndex(y),
               coordinates: {
                 rowIndex: x,
                 colIndex: y,
@@ -684,7 +673,6 @@ const QueryResultCellRenderer = observer(
           }
         }
       }
-
       resultState.setMouseOverCell(resultState.selectedCells[0] ?? null);
     };
 
@@ -741,20 +729,6 @@ const QueryBuilderGridResult = observer(
 
     const resultState = queryBuilderState.resultState;
 
-    const rowData = executionResult.result.rows.map((_row, rowIdx) => {
-      const row: PlainObject = {};
-      const cols = executionResult.result.columns;
-      _row.values.forEach((value, colIdx) => {
-        // `ag-grid` shows `false` value as empty string so we have
-        // call `.toString()` to avoid this behavior.
-        // See https://github.com/finos/legend-studio/issues/1008
-        row[cols[colIdx] as string] = isBoolean(value) ? String(value) : value;
-      });
-
-      row.rowNumber = rowIdx;
-      return row;
-    });
-
     return (
       <div className="query-builder__result__values__table">
         <div
@@ -763,7 +737,20 @@ const QueryBuilderGridResult = observer(
           )}
         >
           <DataGrid
-            rowData={rowData}
+            rowData={queryBuilderState.resultState.getRowData()}
+            onSortChanged={(params) => {
+              const sortedData: Record<
+                string,
+                string | number | boolean | null
+              >[] = [];
+              params.api.forEachNodeAfterFilterAndSort((node, index) => {
+                node.rowIndex = index;
+                // rowNumber has to be manually updated after sorting the column
+                node.data.rowNumber = index;
+                sortedData.push(node.data);
+              });
+              queryBuilderState.resultState.setRowData(sortedData);
+            }}
             gridOptions={{
               suppressScrollOnNewData: true,
               getRowId: (data) => data.data.rowNumber,

package/src/components/filter/QueryBuilderFilterPanel.tsx

@@ -113,6 +113,7 @@ import {
 import { QueryBuilderTelemetryHelper } from '../../__lib__/QueryBuilderTelemetryHelper.js';
 import { getPropertyChainName } from '../../stores/QueryBuilderPropertyEditorState.js';
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../graph/QueryBuilderMetaModelConst.js';
+import { buildPropertyExpressionChain } from '../../stores/QueryBuilderValueSpecificationBuilderHelper.js';
 
 const isCollectionProperty = (
   propertyExpression: AbstractPropertyExpression,
@@ -151,7 +152,7 @@ const isCollectionProperty = (
 export const buildFilterTreeWithExists = (
   propertyExpression: AbstractPropertyExpression,
   filterState: QueryBuilderFilterState,
-  targetDropNode?: QueryBuilderFilterTreeOperationNodeData,
+  targetDropNode?: QueryBuilderFilterTreeNodeData,
 ): void => {
   // 1. Decompose property expression
   const expressions: (AbstractPropertyExpression | SimpleFunctionExpression)[] =
@@ -294,7 +295,21 @@ export const buildFilterTreeWithExists = (
                 .value.path,
         );
         if (parentPropertyChainIndex >= 0) {
-          parentNode = targetDropNode;
+          // Here we choose parentNode based on what the type of targetDropNode
+          // 1. QueryBuilderFilterTreeConditionNodeData: In this case we would want to
+          // add a new group condition from the targetDropNode and add new exists node
+          // getting created as it's child so the parent would be the new group node
+          // 2. QueryBuilderFilterTreeGroupNodeData: Parent node would be same as
+          // targetDropNode
+          // 3. QueryBuilderFilterTreeBlankConditionNodeData: parentNode would be the
+          // parent of the targetDropNode. At the end we would deelete this blank node
+          // that got created.
+          parentNode =
+            targetDropNode instanceof QueryBuilderFilterTreeConditionNodeData
+              ? filterState.newGroupConditionFromNode(targetDropNode)
+              : targetDropNode instanceof QueryBuilderFilterTreeGroupNodeData
+              ? targetDropNode
+              : filterState.getParentNode(targetDropNode);
           existsLambdaPropertyChains = existsLambdaPropertyChains.slice(
             parentPropertyChainIndex + 1,
           );
@@ -303,7 +318,12 @@ export const buildFilterTreeWithExists = (
           );
         }
       } else if (!parentId) {
-        parentNode = targetDropNode;
+        parentNode =
+          targetDropNode instanceof QueryBuilderFilterTreeConditionNodeData
+            ? filterState.newGroupConditionFromNode(targetDropNode)
+            : targetDropNode instanceof QueryBuilderFilterTreeGroupNodeData
+            ? targetDropNode
+            : filterState.getParentNode(targetDropNode);
       }
     }
   }
@@ -332,6 +352,127 @@ export const buildFilterTreeWithExists = (
     filterConditionState,
   );
   filterState.addNodeFromNode(treeNode, parentNode);
+  if (targetDropNode instanceof QueryBuilderFilterTreeBlankConditionNodeData) {
+    filterState.removeNodeAndPruneBranch(targetDropNode);
+  }
+};
+
+export const buildPropertyExpressionFromExistsNode = (
+  filterState: QueryBuilderFilterState,
+  existsNode: QueryBuilderFilterTreeExistsNodeData,
+  node: QueryBuilderFilterTreeConditionNodeData,
+): AbstractPropertyExpression => {
+  let nodeParent = filterState.getParentNode(node);
+  let existsLambdaParameterNames: string[] = [];
+  let existsLambdaExpressions: AbstractPropertyExpression[] = [];
+  existsLambdaExpressions.push(
+    node.condition.propertyExpressionState.propertyExpression,
+  );
+  existsLambdaParameterNames.push(
+    nodeParent?.lambdaParameterName ?? filterState.lambdaParameterName,
+  );
+  while (nodeParent && nodeParent.id !== existsNode.id) {
+    if (nodeParent instanceof QueryBuilderFilterTreeExistsNodeData) {
+      existsLambdaExpressions.push(
+        nodeParent.propertyExpressionState.propertyExpression,
+      );
+      existsLambdaParameterNames.push(
+        nodeParent.lambdaParameterName ?? filterState.lambdaParameterName,
+      );
+    }
+    nodeParent = filterState.getParentNode(nodeParent);
+  }
+  if (nodeParent?.id === existsNode.id) {
+    existsLambdaExpressions.push(
+      existsNode.propertyExpressionState.propertyExpression,
+    );
+    existsLambdaParameterNames.push(
+      existsNode.lambdaParameterName ?? filterState.lambdaParameterName,
+    );
+  }
+  existsLambdaParameterNames = existsLambdaParameterNames.reverse();
+  existsLambdaExpressions = existsLambdaExpressions.reverse();
+
+  const initialPropertyExpression = guaranteeNonNullable(
+    existsLambdaExpressions[0],
+  );
+  existsLambdaParameterNames = existsLambdaParameterNames.slice(1);
+  existsLambdaExpressions = existsLambdaExpressions.slice(1);
+
+  let flattenedPropertyExpressionChain = new AbstractPropertyExpression('');
+  flattenedPropertyExpressionChain.func = initialPropertyExpression.func;
+  flattenedPropertyExpressionChain.parametersValues = [
+    ...initialPropertyExpression.parametersValues,
+  ];
+  for (const exp of existsLambdaExpressions) {
+    // when rebuilding the property expression chain, disregard the initial variable that starts the chain
+    const expressions: (
+      | AbstractPropertyExpression
+      | SimpleFunctionExpression
+    )[] = [];
+    let currentExpression: ValueSpecification = exp;
+    while (
+      currentExpression instanceof AbstractPropertyExpression ||
+      (currentExpression instanceof SimpleFunctionExpression &&
+        matchFunctionName(
+          currentExpression.functionName,
+          QUERY_BUILDER_SUPPORTED_FUNCTIONS.SUBTYPE,
+        ))
+    ) {
+      if (currentExpression instanceof SimpleFunctionExpression) {
+        const functionExpression = new SimpleFunctionExpression(
+          extractElementNameFromPath(QUERY_BUILDER_SUPPORTED_FUNCTIONS.SUBTYPE),
+        );
+        functionExpression.parametersValues.unshift(
+          guaranteeNonNullable(currentExpression.parametersValues[1]),
+        );
+        expressions.push(functionExpression);
+      } else if (currentExpression instanceof AbstractPropertyExpression) {
+        const propertyExp = new AbstractPropertyExpression('');
+        propertyExp.func = currentExpression.func;
+        // NOTE: we must retain the rest of the parameters as those are derived property parameters
+        propertyExp.parametersValues =
+          currentExpression.parametersValues.length > 1
+            ? currentExpression.parametersValues.slice(1)
+            : [];
+        expressions.push(propertyExp);
+      }
+      currentExpression = guaranteeNonNullable(
+        currentExpression.parametersValues[0],
+      );
+    }
+    assertTrue(
+      expressions.length > 0,
+      `Can't process exists() expression: exists() usage with non-chain property expression is not supported`,
+    );
+    for (let i = 0; i < expressions.length - 1; ++i) {
+      (
+        expressions[i] as AbstractPropertyExpression | SimpleFunctionExpression
+      ).parametersValues.unshift(
+        expressions[i + 1] as
+          | AbstractPropertyExpression
+          | SimpleFunctionExpression,
+      );
+    }
+    (
+      expressions[expressions.length - 1] as
+        | AbstractPropertyExpression
+        | SimpleFunctionExpression
+    ).parametersValues.unshift(flattenedPropertyExpressionChain);
+    flattenedPropertyExpressionChain = guaranteeType(
+      expressions[0],
+      AbstractPropertyExpression,
+      `Can't process exists() expression: can't flatten to a property expression`,
+    );
+  }
+  return guaranteeType(
+    buildPropertyExpressionChain(
+      flattenedPropertyExpressionChain,
+      filterState.queryBuilderState,
+      existsNode.lambdaParameterName ?? filterState.lambdaParameterName,
+    ),
+    AbstractPropertyExpression,
+  );
 };
 
 /**
@@ -340,7 +481,7 @@ export const buildFilterTreeWithExists = (
 const buildFilterTree = (
   propertyExpression: AbstractPropertyExpression,
   filterState: QueryBuilderFilterState,
-  targetDropNode?: QueryBuilderFilterTreeOperationNodeData | undefined,
+  targetDropNode?: QueryBuilderFilterTreeNodeData | undefined,
 ): void => {
   if (isCollectionProperty(propertyExpression)) {
     const propertyChainName = getPropertyChainName(
@@ -383,12 +524,88 @@ const buildFilterTree = (
       undefined,
       filterConditionState,
     );
-    filterState.addNodeFromNode(
-      treeNode,
-      targetDropNode instanceof QueryBuilderFilterTreeGroupNodeData
-        ? targetDropNode
-        : undefined,
-    );
+    // Check if there are any exists node present in the parent nodes of the target.
+    // This would change the way we build the filter tree
+    let cn: QueryBuilderFilterTreeNodeData | undefined = targetDropNode;
+    let existsNode: QueryBuilderFilterTreeExistsNodeData | undefined =
+      undefined;
+    let parentId = targetDropNode?.parentId;
+    while (parentId) {
+      cn = filterState.nodes.get(parentId);
+      parentId = cn?.parentId;
+      if (cn instanceof QueryBuilderFilterTreeExistsNodeData) {
+        existsNode = cn;
+      }
+    }
+    if (cn instanceof QueryBuilderFilterTreeExistsNodeData) {
+      existsNode = cn;
+    }
+    if (targetDropNode instanceof QueryBuilderFilterTreeGroupNodeData) {
+      if (existsNode) {
+        filterState.newGroupConditionFromNode(
+          existsNode,
+          treeNode,
+          targetDropNode.groupOperation,
+        );
+      } else {
+        filterState.addNodeFromNode(treeNode, targetDropNode);
+      }
+    } else if (
+      targetDropNode instanceof QueryBuilderFilterTreeBlankConditionNodeData
+    ) {
+      if (existsNode) {
+        filterState.queryBuilderState.applicationStore.notificationService.notifyError(
+          `Can't drag and drop here: property expression of target and source doesn't match`,
+        );
+      } else {
+        filterState.replaceBlankNodeWithNode(treeNode, targetDropNode);
+      }
+    } else if (
+      existsNode &&
+      targetDropNode instanceof QueryBuilderFilterTreeExistsNodeData
+    ) {
+      filterState.newGroupConditionFromNode(existsNode, treeNode);
+    } else if (
+      targetDropNode instanceof QueryBuilderFilterTreeConditionNodeData
+    ) {
+      const parentNode = filterState.getParentNode(targetDropNode);
+      if (
+        existsNode &&
+        parentNode instanceof QueryBuilderFilterTreeExistsNodeData &&
+        parentNode.childrenIds.length === 1
+      ) {
+        filterState.newGroupConditionFromNode(
+          existsNode,
+          treeNode,
+          QUERY_BUILDER_GROUP_OPERATION.AND,
+        );
+      } else if (
+        existsNode &&
+        parentNode instanceof QueryBuilderFilterTreeGroupNodeData
+      ) {
+        const propertyExpression1 = buildPropertyExpressionFromExistsNode(
+          filterState,
+          existsNode,
+          targetDropNode,
+        );
+        filterState.removeNodeAndPruneBranch(targetDropNode);
+        filterState.newGroupConditionFromNode(
+          existsNode,
+          treeNode,
+          parentNode.groupOperation,
+        );
+        const newParentNode = filterState.getParentNode(treeNode);
+        buildFilterTreeWithExists(
+          propertyExpression1,
+          filterState,
+          newParentNode,
+        );
+      } else {
+        filterState.newGroupWithConditionFromNode(treeNode, targetDropNode);
+      }
+    } else {
+      filterState.addNodeFromNode(treeNode, undefined);
+    }
   }
 };
 
@@ -604,7 +821,12 @@ const QueryBuilderFilterConditionEditor = observer(
     };
 
     return (
-      <div className="query-builder-filter-tree__node__label__content dnd__entry__container">
+      <div
+        className="query-builder-filter-tree__node__label__content dnd__entry__container"
+        data-testid={
+          QUERY_BUILDER_TEST_ID.QUERY_BUILDER_FILTER_TREE_CONDITION_NODE_CONTENT
+        }
+      >
         <PanelEntryDropZonePlaceholder
           isDragOver={isDragOver}
           label="Add New Logical Group"
@@ -845,21 +1067,17 @@ const QueryBuilderFilterTreeNodeContainer = observer(
               node,
             );
           } else if (node instanceof QueryBuilderFilterTreeConditionNodeData) {
-            filterState.newGroupWithConditionFromNode(
-              new QueryBuilderFilterTreeConditionNodeData(
-                undefined,
-                filterConditionState,
-              ),
+            buildFilterTree(
+              filterConditionState.propertyExpressionState.propertyExpression,
+              filterState,
               node,
             );
           } else if (
             node instanceof QueryBuilderFilterTreeBlankConditionNodeData
           ) {
-            filterState.replaceBlankNodeWithNode(
-              new QueryBuilderFilterTreeConditionNodeData(
-                undefined,
-                filterConditionState,
-              ),
+            buildFilterTree(
+              filterConditionState.propertyExpressionState.propertyExpression,
+              filterState,
               node,
             );
           }

package/src/stores/QueryBuilderResultState.ts

@@ -17,14 +17,15 @@
 import { action, flow, makeObservable, observable } from 'mobx';
 import {
   type GeneratorFn,
+  type ContentType,
   assertErrorThrown,
   LogEvent,
   guaranteeNonNullable,
-  type ContentType,
   downloadFileUsingDataURI,
   ActionState,
   StopWatch,
   getContentTypeFileExtension,
+  isBoolean,
 } from '@finos/legend-shared';
 import type { QueryBuilderState } from './QueryBuilderState.js';
 import {
@@ -37,6 +38,7 @@ import {
   buildRawLambdaFromLambdaFunction,
   reportGraphAnalytics,
   extractExecutionResultValues,
+  TDSExecutionResult,
 } from '@finos/legend-graph';
 import { buildLambdaFunction } from './QueryBuilderValueSpecificationBuilder.js';
 import { DEFAULT_TAB_SIZE } from '@finos/legend-application';
@@ -81,6 +83,7 @@ export class QueryBuilderResultState {
   latestRunHashCode?: string | undefined;
   queryRunPromise: Promise<ExecutionResult> | undefined = undefined;
   isQueryUsageViewerOpened = false;
+  rowData: Record<string, string | number | boolean | null>[] = [];
 
   selectedCells: QueryBuilderTDSResultCellData[];
   mousedOverCell: QueryBuilderTDSResultCellData | null = null;
@@ -110,6 +113,8 @@ export class QueryBuilderResultState {
       setQueryRunPromise: action,
       setIsQueryUsageViewerOpened: action,
       exportData: flow,
+      getRowData: action,
+      setRowData: action,
       runQuery: flow,
       cancelQuery: flow,
       generatePlan: flow,
@@ -124,6 +129,36 @@ export class QueryBuilderResultState {
     );
   }
 
+  getRowData(): Record<string, string | number | boolean | null>[] {
+    if (
+      this.executionResult &&
+      this.executionResult instanceof TDSExecutionResult
+    ) {
+      const data = this.executionResult.result.rows.map((_row, rowIdx) => {
+        const row: Record<string, string | number | boolean | null> = {};
+        const cols = (this.executionResult as TDSExecutionResult).result
+          .columns;
+        _row.values.forEach((value, colIdx) => {
+          // `ag-grid` shows `false` value as empty string so we have
+          // call `.toString()` to avoid this behavior.
+          // See https://github.com/finos/legend-studio/issues/1008
+          row[cols[colIdx] as string] = isBoolean(value)
+            ? String(value)
+            : value;
+        });
+        row.rowNumber = rowIdx;
+        return row;
+      });
+      this.rowData = data;
+      return data;
+    }
+    return [];
+  }
+
+  setRowData(val: Record<string, string | number | boolean | null>[]): void {
+    this.rowData = val;
+  }
+
   setIsSelectingCells(val: boolean): void {
     this.isSelectingCells = val;
   }