@finos/legend-application-repl 0.0.47 → 0.0.49

package/src/stores/dataCube/core/filter/DataCubeQueryFilterOperation__StartWithCaseInsensitive.tsx

@@ -0,0 +1,93 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { type V1_AppliedFunction } from '@finos/legend-graph';
+import {
+  DataCubeQueryFilterOperation,
+  generateDefaultFilterConditionPrimitiveTypeValue,
+  ofType,
+} from './DataCubeQueryFilterOperation.js';
+import type {
+  DataCubeQuerySnapshotColumn,
+  DataCubeQuerySnapshotFilterCondition,
+} from '../DataCubeQuerySnapshot.js';
+import {
+  DataCubeFunction,
+  DataCubeQueryFilterOperator,
+  type DataCubeOperationValue,
+} from '../DataCubeQueryEngine.js';
+import {
+  _function,
+  _functionName,
+  _property,
+  _value,
+  _var,
+} from '../DataCubeQueryBuilderUtils.js';
+import { guaranteeNonNullable } from '@finos/legend-shared';
+
+export class DataCubeQueryFilterOperation__StartWithCaseInsensitive extends DataCubeQueryFilterOperation {
+  override get label() {
+    return 'starts with (case-insensitive)';
+  }
+
+  override get textLabel() {
+    return 'startsWith (case-insensitive)';
+  }
+
+  override get description(): string {
+    return 'starts with (case-insensitive)';
+  }
+
+  override get operator(): string {
+    return DataCubeQueryFilterOperator.START_WITH_CASE_INSENSITIVE;
+  }
+
+  isCompatibleWithColumn(column: DataCubeQuerySnapshotColumn) {
+    return ofType(column.type, ['string']);
+  }
+
+  isCompatibleWithValue(value: DataCubeOperationValue) {
+    return (
+      ofType(value.type, ['string']) &&
+      value.value !== undefined &&
+      !Array.isArray(value.value)
+    );
+  }
+
+  generateDefaultValue(column: DataCubeQuerySnapshotColumn) {
+    return {
+      type: column.type,
+      value: generateDefaultFilterConditionPrimitiveTypeValue(column.type),
+    };
+  }
+
+  buildConditionSnapshot(expression: V1_AppliedFunction) {
+    // TODO: @akphi - implement this for roundtrip testing
+    return undefined;
+  }
+
+  buildConditionExpression(condition: DataCubeQuerySnapshotFilterCondition) {
+    const variable = _var();
+    return _function(_functionName(DataCubeFunction.STARTS_WITH), [
+      _function(_functionName(DataCubeFunction.TO_LOWERCASE), [
+        _property(condition.name, variable),
+      ]),
+      _function(_functionName(DataCubeFunction.TO_LOWERCASE), [
+        _value(guaranteeNonNullable(condition.value), variable),
+      ]),
+    ]);
+  }
+}

package/src/stores/dataCube/editor/DataCubeEditorColumnPropertiesPanelState.ts

@@ -30,7 +30,7 @@ import {
 } from '@finos/legend-shared';
 import type { DataCubeConfiguration } from '../core/DataCubeConfiguration.js';
 import {
-  DataCubeAggregateOperation,
+  DataCubeAggregateOperator,
   DataCubeColumnKind,
 } from '../core/DataCubeQueryEngine.js';
 import { PRIMITIVE_TYPE } from '@finos/legend-graph';
@@ -123,7 +123,7 @@ export class DataCubeEditorColumnPropertiesPanelState
             case PRIMITIVE_TYPE.INTEGER:
             case PRIMITIVE_TYPE.DECIMAL:
             case PRIMITIVE_TYPE.FLOAT: {
-              column.setAggregateFunction(DataCubeAggregateOperation.SUM);
+              column.setAggregateFunction(DataCubeAggregateOperator.SUM);
               column.setAggregateFunctionParameters([]);
               break;
             }

package/src/stores/dataCube/editor/DataCubeEditorFilterPanelState.ts

@@ -0,0 +1,295 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { action, computed, makeObservable, observable } from 'mobx';
+import {
+  DataCubeQueryFilterGroupOperator,
+  DataCubeQueryFilterOperator,
+} from '../core/DataCubeQueryEngine.js';
+import type { DataCubeQuerySnapshot } from '../core/DataCubeQuerySnapshot.js';
+import {
+  deepClone,
+  getNonNullableEntry,
+  guaranteeNonNullable,
+} from '@finos/legend-shared';
+import type { DataCubeEditorState } from './DataCubeEditorState.js';
+import type { DataCubeState } from '../DataCubeState.js';
+import type { DataCubeQueryEditorPanelState } from './DataCubeEditorPanelState.js';
+import type { DataCubeConfiguration } from '../core/DataCubeConfiguration.js';
+import {
+  type DataCubeFilterEditorTree,
+  type DataCubeFilterEditorTreeNode,
+  DataCubeFilterEditorConditionGroupTreeNode,
+  DataCubeFilterEditorConditionTreeNode,
+  buildFilterEditorTree,
+  buildFilterQuerySnapshot,
+} from '../core/filter/DataCubeQueryFilterEditorState.js';
+
+export class DataCubeEditorFilterPanelState
+  implements DataCubeQueryEditorPanelState
+{
+  readonly dataCube!: DataCubeState;
+  readonly editor!: DataCubeEditorState;
+
+  tree: DataCubeFilterEditorTree;
+  selectedNode?: DataCubeFilterEditorTreeNode | undefined;
+
+  constructor(editor: DataCubeEditorState) {
+    makeObservable(this, {
+      tree: observable.ref,
+      initializeTree: action,
+      refreshTree: action,
+
+      selectedNode: observable,
+      selectedGroupNode: computed,
+      setSelectedNode: action,
+      addFilterNode: action,
+      removeFilterNode: action,
+      layerFilterNode: action,
+    });
+
+    this.dataCube = editor.dataCube;
+    this.editor = editor;
+    this.tree = {
+      nodes: new Map<string, DataCubeFilterEditorTreeNode>(),
+    };
+  }
+
+  get columns() {
+    // TODO: include leaf-extended columns
+    return this.editor.columns.sourceColumns;
+  }
+
+  initializeTree() {
+    if (this.tree.root === undefined && this.tree.nodes.size === 0) {
+      const root = new DataCubeFilterEditorConditionGroupTreeNode(
+        undefined,
+        DataCubeQueryFilterGroupOperator.AND,
+        undefined,
+      );
+      this.tree.nodes.set(root.uuid, root);
+      this.tree.root = root;
+      const condition = this.generateNewFilterNode(root);
+      if (condition) {
+        root.addChild(condition);
+        this.tree.nodes.set(condition.uuid, condition);
+      }
+      this.refreshTree();
+    }
+  }
+
+  refreshTree() {
+    this.tree = { ...this.tree };
+  }
+
+  get selectedGroupNode():
+    | DataCubeFilterEditorConditionGroupTreeNode
+    | undefined {
+    return this.selectedNode instanceof
+      DataCubeFilterEditorConditionGroupTreeNode
+      ? this.selectedNode
+      : this.selectedNode?.parent;
+  }
+
+  setSelectedNode(node: DataCubeFilterEditorTreeNode | undefined) {
+    this.selectedNode = node;
+  }
+
+  private generateNewFilterNode(baseNode: DataCubeFilterEditorTreeNode) {
+    if (baseNode instanceof DataCubeFilterEditorConditionTreeNode) {
+      return new DataCubeFilterEditorConditionTreeNode(
+        undefined,
+        baseNode.column,
+        baseNode.operation,
+        deepClone(baseNode.value),
+        baseNode.not,
+      );
+    } else if (baseNode instanceof DataCubeFilterEditorConditionGroupTreeNode) {
+      if (this.editor.columnProperties.columns.length !== 0) {
+        const columnConfig = getNonNullableEntry(
+          this.editor.columnProperties.columns,
+          0,
+        );
+        const column = {
+          name: columnConfig.name,
+          type: columnConfig.type,
+        };
+        const operation = this.dataCube.engine.getFilterOperation(
+          DataCubeQueryFilterOperator.EQUAL,
+        );
+        return new DataCubeFilterEditorConditionTreeNode(
+          undefined,
+          column,
+          operation,
+          operation.generateDefaultValue(column),
+          undefined,
+        );
+      }
+    }
+    return undefined;
+  }
+
+  /**
+   * Add a new filter condition node just after the specified filter node.
+   * The added node is a clone of the specified node to make the filter's overall match unaffected,
+   * except if the specified node is a group node, then a new (default) condition will be added.
+   */
+  addFilterNode(baseNode: DataCubeFilterEditorTreeNode) {
+    if (this.tree.root) {
+      const node = this.generateNewFilterNode(baseNode);
+      const parentNode = baseNode.parent;
+      if (parentNode && node) {
+        parentNode.addChild(
+          node,
+          baseNode instanceof DataCubeFilterEditorConditionTreeNode
+            ? parentNode.children.indexOf(baseNode) + 1
+            : undefined,
+        );
+
+        this.tree.nodes.set(node.uuid, node);
+        this.refreshTree();
+      }
+    }
+  }
+
+  /**
+   * Remove the specified filter node.
+   * If its parent node has just one child, then flatten the parent node if:
+   * 1. parent node is not the root node and has exactly one child left
+   * 2. OR parent node is the root node and has no child left, in this case,
+   *    flattening means completely remove the filter tree
+   */
+  removeFilterNode(nodeToRemove: DataCubeFilterEditorTreeNode) {
+    if (this.tree.root) {
+      const parentNode = nodeToRemove.parent;
+      // skip root node
+      if (nodeToRemove !== this.tree.root && parentNode) {
+        // remove all nodes in the subtree
+        let childNodesToRemove = [nodeToRemove];
+        while (childNodesToRemove.length) {
+          childNodesToRemove.forEach((node) => {
+            if (node instanceof DataCubeFilterEditorConditionGroupTreeNode) {
+              node.children.forEach((child) => {
+                child.setParent(undefined);
+              });
+            }
+            this.tree.nodes.delete(node.uuid);
+          });
+          childNodesToRemove = Array.from(this.tree.nodes.values()).filter(
+            (node) => node !== this.tree.root && !node.parent,
+          );
+        }
+
+        // remove node from parent
+        parentNode.removeChild(nodeToRemove);
+        this.tree.nodes.delete(nodeToRemove.uuid);
+
+        // flatten parent node if
+        // 1. parent node is not the root node and has exactly one child left
+        // 2. OR parent node is the root node and has no child left, in this case,
+        // flattening means completely remove the filter tree
+        if (parentNode.children.length === 1) {
+          if (parentNode !== this.tree.root) {
+            const childNode = getNonNullableEntry(parentNode.children, 0);
+            const grandParentNode = guaranteeNonNullable(parentNode.parent);
+
+            parentNode.removeChild(childNode);
+
+            const parentNodeIndex =
+              grandParentNode.children.indexOf(parentNode);
+            grandParentNode.removeChild(parentNode);
+            this.tree.nodes.delete(parentNode.uuid);
+
+            grandParentNode.addChild(childNode, parentNodeIndex);
+          }
+        } else if (parentNode.children.length === 0) {
+          if (parentNode === this.tree.root) {
+            this.tree.root = undefined;
+            this.tree.nodes.delete(parentNode.uuid);
+          }
+        }
+
+        this.refreshTree();
+
+        if (this.selectedNode === nodeToRemove) {
+          this.setSelectedNode(undefined);
+        }
+      }
+    }
+  }
+
+  /**
+   * Replace the specified filter node with a group which contains
+   * the specified node and a new condition node.
+   * The added node is a clone of the specified node to make the filter's overall match unaffected,
+   * except if the specified node is a group node, then a new (default) condition will be added.
+   */
+  layerFilterNode(baseNode: DataCubeFilterEditorTreeNode) {
+    if (this.tree.root) {
+      const node = this.generateNewFilterNode(baseNode);
+      const parentNode = baseNode.parent;
+      if (parentNode && node) {
+        const baseNodeIndex = parentNode.children.indexOf(baseNode);
+        parentNode.removeChild(baseNode);
+
+        const subGroupNode = new DataCubeFilterEditorConditionGroupTreeNode(
+          undefined,
+          // Use OR condition when we create sub-group to relax filtering
+          DataCubeQueryFilterGroupOperator.OR,
+          undefined,
+        );
+
+        subGroupNode.addChild(baseNode);
+        subGroupNode.addChild(node);
+        parentNode.addChild(subGroupNode, baseNodeIndex);
+
+        this.tree.nodes.set(subGroupNode.uuid, subGroupNode);
+        this.tree.nodes.set(node.uuid, node);
+        this.refreshTree();
+
+        if (this.selectedNode === baseNode) {
+          this.setSelectedNode(subGroupNode);
+        }
+      }
+    }
+  }
+
+  applySnaphot(
+    snapshot: DataCubeQuerySnapshot,
+    configuration: DataCubeConfiguration,
+  ): void {
+    this.tree.nodes = new Map<string, DataCubeFilterEditorTreeNode>();
+    this.tree.root = snapshot.data.filter
+      ? buildFilterEditorTree(
+          snapshot.data.filter,
+          undefined,
+          this.tree.nodes,
+          (op) => this.dataCube.engine.getFilterOperation(op),
+        )
+      : undefined;
+    this.setSelectedNode(undefined);
+    this.refreshTree();
+  }
+
+  buildSnapshot(
+    newSnapshot: DataCubeQuerySnapshot,
+    baseSnapshot: DataCubeQuerySnapshot,
+  ): void {
+    newSnapshot.data.filter = this.tree.root
+      ? buildFilterQuerySnapshot(this.tree.root)
+      : undefined;
+  }
+}

package/src/stores/dataCube/editor/DataCubeEditorSortsPanelState.ts

@@ -17,7 +17,7 @@
 import { action, makeObservable, observable } from 'mobx';
 import type { DataCubeState } from '../DataCubeState.js';
 import { type DataCubeQuerySnapshot } from '../core/DataCubeQuerySnapshot.js';
-import { DataCubeQuerySortOperation } from '../core/DataCubeQueryEngine.js';
+import { DataCubeQuerySortOperator } from '../core/DataCubeQueryEngine.js';
 import type { DataCubeQueryEditorPanelState } from './DataCubeEditorPanelState.js';
 import {
   DataCubeEditorColumnsSelectorColumnState,
@@ -27,13 +27,9 @@ import type { DataCubeEditorState } from './DataCubeEditorState.js';
 import type { DataCubeConfiguration } from '../core/DataCubeConfiguration.js';
 
 export class DataCubeEditorSortColumnState extends DataCubeEditorColumnsSelectorColumnState {
-  operation: DataCubeQuerySortOperation;
+  operation: string;
 
-  constructor(
-    name: string,
-    type: string,
-    direction: DataCubeQuerySortOperation,
-  ) {
+  constructor(name: string, type: string, direction: string) {
     super(name, type);
 
     makeObservable(this, {
@@ -44,7 +40,7 @@ export class DataCubeEditorSortColumnState extends DataCubeEditorColumnsSelector
     this.operation = direction;
   }
 
-  setOperation(val: DataCubeQuerySortOperation) {
+  setOperation(val: DataCubeQuerySortOperator) {
     this.operation = val;
   }
 }
@@ -64,7 +60,7 @@ export class DataCubeEditorSortColumnsSelectorState extends DataCubeEditorColumn
         new DataCubeEditorSortColumnState(
           col.name,
           col.type,
-          DataCubeQuerySortOperation.ASCENDING,
+          DataCubeQuerySortOperator.ASCENDING,
         ),
     );
   }

package/src/stores/dataCube/editor/DataCubeEditorState.tsx

@@ -18,7 +18,7 @@ import { action, makeObservable, observable } from 'mobx';
 import type { DataCubeState } from '../DataCubeState.js';
 import { DataCubeEditorSortsPanelState } from './DataCubeEditorSortsPanelState.js';
 import { DataCubeEditorCodePanelState } from './DataCubeEditorCodePanelState.js';
-import { DataCubeQuerySnapshotSubscriber } from '../core/DataCubeQuerySnapshotSubscriber.js';
+import { DataCubeQuerySnapshotController } from '../core/DataCubeQuerySnapshotManager.js';
 import { type DataCubeQuerySnapshot } from '../core/DataCubeQuerySnapshot.js';
 import { guaranteeNonNullable } from '@finos/legend-shared';
 import { DataCubeEditorGeneralPropertiesPanelState } from './DataCubeEditorGeneralPropertiesPanelState.js';
@@ -28,12 +28,13 @@ import { DataCubeConfiguration } from '../core/DataCubeConfiguration.js';
 import { DataCubeEditorVerticalPivotsPanelState } from './DataCubeEditorVerticalPivotsPanelState.js';
 import { SingletonModeDisplayState } from '../../LayoutManagerState.js';
 import { DataCubeEditor } from '../../../components/dataCube/editor/DataCubeEditor.js';
+import { DataCubeEditorFilterPanelState } from './DataCubeEditorFilterPanelState.js';
 
 export enum DataCubeEditorTab {
   GENERAL_PROPERTIES = 'General Properties',
   COLUMN_PROPERTIES = 'Column Properties',
-  FILTER = 'Filter',
   EXTENDED_COLUMNS = 'Extended Columns',
+  FILTER = 'Filter',
   COLUMNS = 'Columns',
   VERTICAL_PIVOTS = 'Vertical Pivots',
   HORIZONTAL_PIVOTS = 'Horizontal Pivots',
@@ -41,10 +42,11 @@ export enum DataCubeEditorTab {
   CODE = 'Code',
 }
 
-export class DataCubeEditorState extends DataCubeQuerySnapshotSubscriber {
+export class DataCubeEditorState extends DataCubeQuerySnapshotController {
   readonly display: SingletonModeDisplayState;
   readonly generalProperties: DataCubeEditorGeneralPropertiesPanelState;
   readonly columnProperties: DataCubeEditorColumnPropertiesPanelState;
+  readonly filter: DataCubeEditorFilterPanelState;
   readonly columns: DataCubeEditorColumnsPanelState;
   readonly verticalPivots: DataCubeEditorVerticalPivotsPanelState;
   readonly sorts: DataCubeEditorSortsPanelState;
@@ -65,12 +67,13 @@ export class DataCubeEditorState extends DataCubeQuerySnapshotSubscriber {
     this.display = new SingletonModeDisplayState(
       this.dataCube.repl.layout,
       'Properties',
-      () => <DataCubeEditor />,
+      () => <DataCubeEditor dataCube={this.dataCube} />,
     );
     this.generalProperties = new DataCubeEditorGeneralPropertiesPanelState(
       this,
     );
     this.columnProperties = new DataCubeEditorColumnPropertiesPanelState(this);
+    this.filter = new DataCubeEditorFilterPanelState(this);
     this.columns = new DataCubeEditorColumnsPanelState(this);
     this.verticalPivots = new DataCubeEditorVerticalPivotsPanelState(this);
     this.sorts = new DataCubeEditorSortsPanelState(this);
@@ -91,6 +94,7 @@ export class DataCubeEditorState extends DataCubeQuerySnapshotSubscriber {
     this.columns.buildSnapshot(snapshot, baseSnapshot);
     this.verticalPivots.buildSnapshot(snapshot, baseSnapshot);
     this.sorts.buildSnapshot(snapshot, baseSnapshot);
+    this.filter.buildSnapshot(snapshot, baseSnapshot);
 
     // grid configuration must be processed before processing columns' configuration
     // to properly generate the container configuration
@@ -114,12 +118,9 @@ export class DataCubeEditorState extends DataCubeQuerySnapshotSubscriber {
     this.columns.applySnaphot(snapshot, configuration);
     this.verticalPivots.applySnaphot(snapshot, configuration);
     this.sorts.applySnaphot(snapshot, configuration);
+    this.filter.applySnaphot(snapshot, configuration);
 
     this.generalProperties.applySnaphot(snapshot, configuration);
     this.columnProperties.applySnaphot(snapshot, configuration);
   }
-
-  override async initialize() {
-    // do nothing
-  }
 }

package/src/stores/dataCube/editor/DataCubeMutableConfiguration.ts

@@ -18,7 +18,6 @@ import {
   getDataType,
   type DataCubeColumnKind,
   type DataCubeFont,
-  type DataCubeAggregateOperation,
   type DataCubeOperationValue,
   type DataCubeNumberScale,
   type DataCubeSelectionStat,
@@ -54,9 +53,10 @@ export class DataCubeMutableColumnConfiguration extends DataCubeColumnConfigurat
   // NOTE: these configurations are synthesized from the data query, and materialized here
   // to make editing more convenient. They should not be part of the persistent configuration
   // to avoid duplication of information with the data query.
-  aggregateFunction?: DataCubeAggregateOperation | undefined;
+  aggregateFunction?: string | undefined;
   aggregateFunctionParameters: DataCubeOperationValue[] = [];
   excludedFromHorizontalPivot = false;
+  horizontalPivotSortFunction?: string | undefined;
 
   static create(
     json: PlainObject<DataCubeColumnConfiguration>,
@@ -90,9 +90,6 @@ export class DataCubeMutableColumnConfiguration extends DataCubeColumnConfigurat
       missingValueDisplayText: observable,
       setMissingValueDisplayText: action,
 
-      hPivotSortFunction: observable,
-      setHPivotSortFunction: action,
-
       fontFamily: observable,
       setFontFamily: action,
 
@@ -176,6 +173,9 @@ export class DataCubeMutableColumnConfiguration extends DataCubeColumnConfigurat
 
       excludedFromHorizontalPivot: observable,
       setExcludedFromHorizontalPivot: action,
+
+      horizontalPivotSortFunction: observable,
+      setHorizontalPivotSortFunction: action,
     });
 
     return configuration;
@@ -259,10 +259,6 @@ export class DataCubeMutableColumnConfiguration extends DataCubeColumnConfigurat
     this.missingValueDisplayText = value;
   }
 
-  setHPivotSortFunction(value: string | undefined) {
-    this.hPivotSortFunction = value;
-  }
-
   setFontFamily(value: DataCubeFont | undefined) {
     this.fontFamily = value;
   }
@@ -359,7 +355,7 @@ export class DataCubeMutableColumnConfiguration extends DataCubeColumnConfigurat
     this.linkLabelParameter = value;
   }
 
-  setAggregateFunction(value: DataCubeAggregateOperation | undefined) {
+  setAggregateFunction(value: string | undefined) {
     this.aggregateFunction = value;
   }
 
@@ -370,6 +366,10 @@ export class DataCubeMutableColumnConfiguration extends DataCubeColumnConfigurat
   setAggregateFunctionParameters(value: DataCubeOperationValue[]) {
     this.aggregateFunctionParameters = value;
   }
+
+  setHorizontalPivotSortFunction(value: string | undefined) {
+    this.horizontalPivotSortFunction = value;
+  }
 }
 
 export class DataCubeMutableConfiguration extends DataCubeConfiguration {

package/src/stores/dataCube/grid/DataCubeGridClientEngine.ts

@@ -52,7 +52,7 @@ export enum DataCubeGridClientExportFormat {
 }
 
 export enum INTERNAL__GridClientUtilityCssClassName {
-  ROOT = 'data-cube-grid.ag-theme-balham',
+  ROOT = 'data-cube-grid.ag-theme-quartz',
   HIGHLIGHT_ROW = 'data-cube-grid__utility--highlight-row',
   SHOW_VERTICAL_GRID_LINES = 'data-cube-grid__utility--show-vertical-grid-lines',
   SHOW_HORIZONTAL_GRID_LINES = 'data-cube-grid__utility--show-horizontal-grid-lines',
@@ -111,6 +111,8 @@ export const INTERNAL__GRID_CLIENT_TOOLTIP_SHOW_DELAY = 1000;
 export const INTERNAL__GRID_CLIENT_AUTO_RESIZE_PADDING = 10;
 export const INTERNAL__GRID_CLIENT_MISSING_VALUE = '__MISSING';
 export const INTERNAL__GRID_CLIENT_TREE_COLUMN_ID = 'INTERNAL__tree';
+export const INTERNAL__GRID_CLIENT_FILTER_TRIGGER_COLUMN_ID =
+  'INTERNAL__filterTrigger';
 export const INTERNAL__GRID_CLIENT_ROW_GROUPING_COUNT_AGG_COLUMN_ID =
   'INTERNAL__count';
 
@@ -124,14 +126,6 @@ export enum GridClientSortDirection {
   DESCENDING = 'desc',
 }
 
-export enum GridClientAggregateOperation {
-  COUNT = 'count',
-  SUM = 'sum',
-  MAX = 'max',
-  MIN = 'min',
-  AVERAGE = 'avg',
-}
-
 export function getDataForAllNodes<T>(client: GridApi<T>): T[] {
   const rows: T[] = [];
   client.forEachNode((node: IRowNode<T>) => {
@@ -221,20 +215,25 @@ export class DataCubeGridClientServerSideDataSource
     // ------------------------------ DATA ------------------------------
 
     try {
-      const executableQuery = buildExecutableQuery(syncedSnapshot, {
-        postProcessor: generateRowGroupingDrilldownExecutableQueryPostProcessor(
-          params.request.groupKeys,
-        ),
-        pagination:
-          this.grid.isPaginationEnabled &&
-          params.request.startRow !== undefined &&
-          params.request.endRow !== undefined
-            ? {
-                start: params.request.startRow,
-                end: params.request.endRow,
-              }
-            : undefined,
-      });
+      const executableQuery = buildExecutableQuery(
+        syncedSnapshot,
+        this.grid.dataCube.engine.filterOperations,
+        {
+          postProcessor:
+            generateRowGroupingDrilldownExecutableQueryPostProcessor(
+              params.request.groupKeys,
+            ),
+          pagination:
+            this.grid.isPaginationEnabled &&
+            params.request.startRow !== undefined &&
+            params.request.endRow !== undefined
+              ? {
+                  start: params.request.startRow,
+                  end: params.request.endRow,
+                }
+              : undefined,
+        },
+      );
       const lambda = new V1_Lambda();
       lambda.body.push(executableQuery);
       const result = await this.grid.dataCube.engine.executeQuery(lambda);

package/src/stores/dataCube/grid/DataCubeGridClientExportEngine.ts

@@ -90,7 +90,7 @@ export class DataCubeGridClientExportEngine {
   }
 
   private generateFileName() {
-    return `${this.dataCube.core.name} - ${formatDate(new Date(), 'EEE MMM dd yyyy HH_mm_ss')}`;
+    return `${this.dataCube.staticContent.name} - ${formatDate(new Date(), 'EEE MMM dd yyyy HH_mm_ss')}`;
   }
 
   exportFile(format: DataCubeGridClientExportFormat) {