@finos/legend-application-repl 0.0.21 → 0.0.23

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

@@ -0,0 +1,198 @@
+/**
+ * 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 type { DataCubeState } from '../DataCubeState.js';
+import type {
+  DataCubeQuerySnapshot,
+  DataCubeQuerySnapshotColumn,
+  DataCubeQuerySnapshotSortColumn,
+} from '../core/DataCubeQuerySnapshot.js';
+import type { DataCubeQueryEditorSubState } from './DataCubeEditorQuerySnapshotBuilder.js';
+import { deepEqual } from '@finos/legend-shared';
+import { DATA_CUBE_COLUMN_SORT_DIRECTION } from '../DataCubeMetaModelConst.js';
+
+export class DataCubeEditorSortColumnState {
+  readonly column: DataCubeQuerySnapshotColumn;
+  direction: DATA_CUBE_COLUMN_SORT_DIRECTION;
+
+  constructor(
+    column: DataCubeQuerySnapshotColumn,
+    direction: DATA_CUBE_COLUMN_SORT_DIRECTION,
+  ) {
+    makeObservable(this, {
+      direction: observable,
+      setDirection: action,
+    });
+
+    this.column = column;
+    this.direction = direction;
+  }
+
+  setDirection(val: DATA_CUBE_COLUMN_SORT_DIRECTION): void {
+    this.direction = val;
+  }
+}
+
+export class DataCubeEditorSortState implements DataCubeQueryEditorSubState {
+  readonly dataCubeState!: DataCubeState;
+
+  availableColumns: DataCubeEditorSortColumnState[] = [];
+  selectedColumns: DataCubeEditorSortColumnState[] = [];
+  availableColumnsSearchText = '';
+  selectedColumnsSearchText = '';
+
+  constructor(dataCubeState: DataCubeState) {
+    this.dataCubeState = dataCubeState;
+
+    makeObservable(this, {
+      availableColumns: observable,
+      selectedColumns: observable,
+      availableColumnsSearchText: observable,
+      selectedColumnsSearchText: observable,
+      setAvailableColumns: action,
+      setSelectedColumns: action,
+      addAvailableColumn: action,
+      addSelectedColumn: action,
+      addAllAvailableColumns: action,
+      addAllSelectedColumns: action,
+      setSelectedColumnsSearchText: action,
+      setAvailableColumnsSearchText: action,
+      availableColumnsSearchResults: computed,
+      selectedColumnsSearchResults: computed,
+    });
+  }
+
+  setAvailableColumns(val: DataCubeEditorSortColumnState[]): void {
+    this.availableColumns = val;
+  }
+
+  setSelectedColumns(val: DataCubeEditorSortColumnState[]): void {
+    this.selectedColumns = val;
+  }
+
+  addAvailableColumn(columnName: string): void {
+    const column = this.availableColumns.find(
+      (col) => col.column.name === columnName,
+    );
+    if (column) {
+      this.setAvailableColumns(
+        this.availableColumns.filter((col) => col.column.name !== columnName),
+      );
+      this.setSelectedColumns(this.selectedColumns.concat(column));
+    }
+  }
+
+  addSelectedColumn(columnName: string): void {
+    const column = this.selectedColumns.find(
+      (col) => col.column.name === columnName,
+    );
+    if (column) {
+      this.setSelectedColumns(
+        this.selectedColumns.filter((col) => col.column.name !== columnName),
+      );
+      this.setAvailableColumns(this.availableColumns.concat(column));
+    }
+  }
+
+  addAllAvailableColumns(): void {
+    this.setSelectedColumns(this.selectedColumns.concat(this.availableColumns));
+    this.setAvailableColumns([]);
+  }
+
+  addAllSelectedColumns(): void {
+    this.setAvailableColumns(
+      this.availableColumns.concat(this.selectedColumns),
+    );
+    this.setSelectedColumns([]);
+  }
+
+  setAvailableColumnsSearchText(val: string): void {
+    this.availableColumnsSearchText = val;
+  }
+
+  setSelectedColumnsSearchText(val: string): void {
+    this.selectedColumnsSearchText = val;
+  }
+
+  get availableColumnsSearchResults(): DataCubeEditorSortColumnState[] {
+    if (this.availableColumnsSearchText) {
+      return this.availableColumns.filter((col) =>
+        col.column.name
+          .toLowerCase()
+          .includes(this.availableColumnsSearchText.toLowerCase()),
+      );
+    } else {
+      return this.availableColumns;
+    }
+  }
+
+  get selectedColumnsSearchResults(): DataCubeEditorSortColumnState[] {
+    if (this.selectedColumnsSearchText) {
+      return this.selectedColumns.filter((col) =>
+        col.column.name
+          .toLowerCase()
+          .includes(this.selectedColumnsSearchText.toLowerCase()),
+      );
+    } else {
+      return this.selectedColumns;
+    }
+  }
+
+  applySnaphot(snapshot: DataCubeQuerySnapshot): void {
+    const sortColumns = snapshot.sortColumns;
+    this.setAvailableColumns(
+      snapshot.columns
+        .filter(
+          (col) => !sortColumns.find((sortCol) => sortCol.name === col.name),
+        )
+        .map(
+          (col) =>
+            new DataCubeEditorSortColumnState(
+              col,
+              DATA_CUBE_COLUMN_SORT_DIRECTION.ASCENDING,
+            ),
+        ),
+    );
+    this.setSelectedColumns(
+      sortColumns.map(
+        (sortCol) =>
+          new DataCubeEditorSortColumnState(
+            snapshot.columns.find((col) => col.name === sortCol.name)!,
+            sortCol.direction,
+          ),
+      ),
+    );
+  }
+
+  buildSnapshot(
+    newSnapshot: DataCubeQuerySnapshot,
+    baseSnapshot: DataCubeQuerySnapshot,
+  ): boolean {
+    const newSortColumns: DataCubeQuerySnapshotSortColumn[] =
+      this.selectedColumns.map((sortInfo) => ({
+        name: sortInfo.column.name,
+        type: sortInfo.column.type,
+        direction: sortInfo.direction,
+      }));
+
+    if (!deepEqual(newSortColumns, baseSnapshot.sortColumns)) {
+      newSnapshot.sortColumns = newSortColumns;
+      return true;
+    }
+    return false;
+  }
+}

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

@@ -0,0 +1,94 @@
+/**
+ * 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, makeObservable, observable } from 'mobx';
+import type { DataCubeState } from '../DataCubeState.js';
+import { DataCubeEditorSortState } from './DataCubeEditorSortState.js';
+import { DataCubeQueryCodeEditorState } from './DataCubeEditorCodeState.js';
+import { DataCubeQuerySnapshotSubscriber } from '../core/DataCubeQuerySnapshotSubscriber.js';
+import {
+  cloneSnapshot,
+  type DataCubeQuerySnapshot,
+} from '../core/DataCubeQuerySnapshot.js';
+import { guaranteeNonNullable } from '@finos/legend-shared';
+
+export enum DATA_CUBE_EDITOR_TAB {
+  COLUMNS = 'Columns',
+  VERTICAL_PIVOTS = 'VPivots',
+  HORIZONTAL_PIVOTS = 'HPivots',
+  SORTS = 'Sorts',
+  EXTENDED_COLUMNS = 'Extended Columns',
+  GENERAL_PROPERTIES = 'General Properties',
+  COLUMN_PROPERTIES = 'Column Properties',
+  Code = 'Code',
+  // DEVELOPER_OPTIONS = 'Developer',
+  // PIVOT_LAYOUT = 'Pivot Layout',
+}
+
+export class DataCubeEditorState extends DataCubeQuerySnapshotSubscriber {
+  readonly dataCubeState!: DataCubeState;
+  readonly sort!: DataCubeEditorSortState;
+  readonly codeEditorState!: DataCubeQueryCodeEditorState; // TODO: move to editor state
+
+  isPanelOpen = false;
+  currentTab = DATA_CUBE_EDITOR_TAB.SORTS;
+
+  constructor(dataCubeState: DataCubeState) {
+    super(dataCubeState.snapshotManager);
+
+    makeObservable(this, {
+      applyChanges: action,
+
+      currentTab: observable,
+      setCurrentTab: action,
+
+      isPanelOpen: observable,
+      openPanel: action,
+      closePanel: action,
+    });
+
+    this.codeEditorState = new DataCubeQueryCodeEditorState(this.dataCubeState);
+    this.dataCubeState = dataCubeState;
+    this.sort = new DataCubeEditorSortState(this.dataCubeState);
+  }
+
+  openPanel(): void {
+    this.isPanelOpen = true;
+  }
+
+  closePanel(): void {
+    this.isPanelOpen = false;
+  }
+
+  setCurrentTab(val: DATA_CUBE_EDITOR_TAB): void {
+    this.currentTab = val;
+  }
+
+  applyChanges(): void {
+    // let createNew = false;
+    const baseSnapshot = guaranteeNonNullable(this.getLatestSnapshot());
+    const snapshot = cloneSnapshot(baseSnapshot);
+    const createNew = this.sort.buildSnapshot(snapshot, baseSnapshot);
+
+    if (createNew) {
+      this.publishSnapshot(snapshot);
+    }
+  }
+
+  override async applySnapshot(snapshot: DataCubeQuerySnapshot): Promise<void> {
+    this.sort.applySnaphot(snapshot);
+  }
+}

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

@@ -0,0 +1,152 @@
+/**
+ * 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 {
+  IServerSideDatasource,
+  IServerSideGetRowsParams,
+  IServerSideGetRowsRequest,
+} from '@ag-grid-community/core';
+import type { DataCubeGridState } from './DataCubeGridState.js';
+import {
+  cloneSnapshot,
+  type DataCubeQuerySnapshot,
+  type DataCubeQuerySnapshotSortColumn,
+} from '../core/DataCubeQuerySnapshot.js';
+import {
+  LogEvent,
+  assertErrorThrown,
+  deepEqual,
+  guaranteeNonNullable,
+  isBoolean,
+} from '@finos/legend-shared';
+import { buildExecutableQueryFromSnapshot } from '../core/DataCubeQueryBuilder.js';
+import { type TabularDataSet, V1_Lambda } from '@finos/legend-graph';
+import { DATA_CUBE_COLUMN_SORT_DIRECTION } from '../DataCubeMetaModelConst.js';
+import { APPLICATION_EVENT } from '@finos/legend-application';
+
+export type GridClientResultCellDataType =
+  | string
+  | number
+  | boolean
+  | null
+  | undefined;
+
+export type GridClientRowDataType = {
+  [key: string]: GridClientResultCellDataType;
+};
+
+export enum GridClientSortDirection {
+  ASCENDING = 'asc',
+  DESCENDING = 'desc',
+}
+
+export const toRowData = (tds: TabularDataSet): GridClientRowDataType[] =>
+  tds.rows.map((_row, rowIdx) => {
+    const row: GridClientRowDataType = {};
+    const cols = tds.columns;
+    _row.values.forEach((value, colIdx) => {
+      // `ag-grid` shows `false` value as empty string so we have
+      // call `.toString()` to avoid this behavior.
+      row[cols[colIdx] as string] = isBoolean(value) ? String(value) : value;
+    });
+    row.rowNumber = rowIdx;
+    return row;
+  });
+
+export class DataCubeGridClientServerSideDataSource
+  implements IServerSideDatasource
+{
+  readonly grid: DataCubeGridState;
+
+  constructor(grid: DataCubeGridState) {
+    this.grid = grid;
+  }
+
+  async fetchRows(
+    params: IServerSideGetRowsParams<unknown, unknown>,
+  ): Promise<void> {
+    const currentSnapshot = guaranteeNonNullable(this.grid.getLatestSnapshot());
+    const syncedSnapshot = this.syncSnapshot(params.request, currentSnapshot);
+    if (syncedSnapshot.uuid !== currentSnapshot.uuid) {
+      this.grid.publishSnapshot(syncedSnapshot);
+    }
+    try {
+      const executableQuery = buildExecutableQueryFromSnapshot(syncedSnapshot);
+      const lambda = new V1_Lambda();
+      lambda.body.push(executableQuery);
+      const result = await this.grid.dataCubeState.engine.executeQuery(lambda);
+      const rowData = toRowData(result.result);
+      params.success({ rowData });
+    } catch (error) {
+      assertErrorThrown(error);
+      this.grid.dataCubeState.applicationStore.notificationService.notifyError(
+        error,
+      );
+      params.fail();
+    }
+  }
+
+  getRows(params: IServerSideGetRowsParams<unknown, unknown>): void {
+    this.fetchRows(params).catch((error: unknown) => {
+      assertErrorThrown(error);
+      this.grid.dataCubeState.applicationStore.logService.error(
+        LogEvent.create(APPLICATION_EVENT.ILLEGAL_APPLICATION_STATE_OCCURRED),
+        `Error ocurred while fetching data for grid should have been handled gracefully`,
+        error,
+      );
+    });
+  }
+
+  private syncSnapshot(
+    request: IServerSideGetRowsRequest,
+    baseSnapshot: DataCubeQuerySnapshot,
+  ): DataCubeQuerySnapshot {
+    let createNew = false;
+
+    // --------------------------------- GROUP BY ---------------------------------
+    // TODO: @akphi - Implement this
+
+    // --------------------------------- SORT ---------------------------------
+
+    const newSortColumns: DataCubeQuerySnapshotSortColumn[] =
+      request.sortModel.map((sortInfo) => {
+        const column = guaranteeNonNullable(
+          baseSnapshot.columns.find((col) => col.name === sortInfo.colId),
+        );
+        return {
+          name: sortInfo.colId,
+          type: column.type,
+          direction:
+            sortInfo.sort === GridClientSortDirection.ASCENDING
+              ? DATA_CUBE_COLUMN_SORT_DIRECTION.ASCENDING
+              : DATA_CUBE_COLUMN_SORT_DIRECTION.DESCENDING,
+        };
+      });
+
+    if (!deepEqual(newSortColumns, baseSnapshot.sortColumns)) {
+      createNew = true;
+    }
+
+    // --------------------------------- FINALIZE ---------------------------------
+
+    if (createNew) {
+      const newSnapshot = cloneSnapshot(baseSnapshot);
+      newSnapshot.sortColumns = newSortColumns;
+      return newSnapshot;
+    }
+    return baseSnapshot;
+  }
+}

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

@@ -0,0 +1,245 @@
+/**
+ * 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 { DataCubeQuerySnapshot } from '../core/DataCubeQuerySnapshot.js';
+import type { GridOptions } from '@ag-grid-community/core';
+import { DATA_CUBE_COLUMN_SORT_DIRECTION } from '../DataCubeMetaModelConst.js';
+import { GridClientSortDirection } from './DataCubeGridClientEngine.js';
+
+// export const getTDSSortOrder = (sortOrder: string): TDS_SORT_ORDER => {
+//   switch (sortOrder) {
+//     case 'asc':
+//       return TDS_SORT_ORDER.ASCENDING;
+//     case 'desc':
+//       return TDS_SORT_ORDER.DESCENDING;
+//     default:
+//       throw new Error(`Unsupported tds sort order ${sortOrder}`);
+//   }
+// };
+
+// const getTDSSortModel = (sort: TDS_SORT_ORDER): string => {
+//   switch (sort) {
+//     case TDS_SORT_ORDER.ASCENDING:
+//       return 'asc';
+//     case TDS_SORT_ORDER.DESCENDING:
+//       return 'desc';
+//     default:
+//       throw new Error(`Unsupported`);
+//   }
+// };
+
+// export const getAggregationFunction = (
+//   aggFunc: string,
+// ): TDS_AGGREGATION_FUNCTION => {
+//   switch (aggFunc) {
+//     case 'sum':
+//       return TDS_AGGREGATION_FUNCTION.SUM;
+//     case 'min':
+//       return TDS_AGGREGATION_FUNCTION.MIN;
+//     case 'max':
+//       return TDS_AGGREGATION_FUNCTION.MAX;
+//     case 'count':
+//       return TDS_AGGREGATION_FUNCTION.COUNT;
+//     default:
+//       throw new Error(`Unsupported aggregation function ${aggFunc}`);
+//   }
+// };
+
+// export const getTDSFilterOperation = (
+//   filterOperation: string,
+// ): TDS_FILTER_OPERATION => {
+//   switch (filterOperation) {
+//     case 'equals':
+//       return TDS_FILTER_OPERATION.EQUALS;
+//     case 'notEqual':
+//       return TDS_FILTER_OPERATION.NOT_EQUAL;
+//     case 'greaterThan':
+//       return TDS_FILTER_OPERATION.GREATER_THAN;
+//     case 'greaterThanOrEqual':
+//       return TDS_FILTER_OPERATION.GREATER_THAN_OR_EQUAL;
+//     case 'lessThan':
+//       return TDS_FILTER_OPERATION.LESS_THAN;
+//     case 'lessThanOrEqual':
+//       return TDS_FILTER_OPERATION.LESS_THAN_OR_EQUAL;
+//     case 'blank':
+//       return TDS_FILTER_OPERATION.BLANK;
+//     case 'notBlank':
+//       return TDS_FILTER_OPERATION.NOT_BLANK;
+//     case 'contains':
+//       return TDS_FILTER_OPERATION.CONTAINS;
+//     case 'notContains':
+//       return TDS_FILTER_OPERATION.NOT_CONTAINS;
+//     case 'startsWith':
+//       return TDS_FILTER_OPERATION.STARTS_WITH;
+//     case 'endsWith':
+//       return TDS_FILTER_OPERATION.ENDS_WITH;
+//     default:
+//       throw new Error(`Unsupported filter operation ${filterOperation}`);
+//   }
+// };
+
+// export const getFilterColumnType = (type: string): PRIMITIVE_TYPE => {
+//   switch (type) {
+//     case 'text':
+//       return PRIMITIVE_TYPE.STRING;
+//     case 'number':
+//       return PRIMITIVE_TYPE.NUMBER;
+//     case 'boolean':
+//       return PRIMITIVE_TYPE.BOOLEAN;
+//     case 'date':
+//       return PRIMITIVE_TYPE.DATE;
+//     default:
+//       throw new Error(`Unsupported filter type ${type}`);
+//   }
+// };
+
+// export const getFilterModeltype = (type: PRIMITIVE_TYPE): string => {
+//   switch (type) {
+//     case PRIMITIVE_TYPE.STRING:
+//       return 'text';
+//     case PRIMITIVE_TYPE.NUMBER:
+//       return 'number';
+//     case PRIMITIVE_TYPE.BOOLEAN:
+//       return 'boolean';
+//     case PRIMITIVE_TYPE.DATE:
+//       return 'date';
+//     default:
+//       throw new Error(`Unsupported filter type ${type}`);
+//   }
+// };
+
+// export const getTDSColumnCustomizations = (
+//   result: TDSExecutionResult,
+//   columnName: string,
+//   tdsRequest?: TDSRequest | undefined,
+// ): object => {
+//   if (!tdsRequest) {
+//     return {};
+//   }
+//   const sort = tdsRequest.sort.find((c) => c.column === columnName)?.order;
+//   const rowGroup = tdsRequest.groupBy.columns.find((c) => c === columnName);
+//   const aggFunc = tdsRequest.groupBy.aggregations.find(
+//     (c) => c.column === columnName,
+//   );
+//   return {
+//     sort: sort ? getTDSSortModel(sort) : undefined,
+//     rowGroup: Boolean(rowGroup),
+//     hide: Boolean(rowGroup),
+//     aggFunc: aggFunc?.function,
+//   };
+// };
+
+// export const getAggregationTDSColumnCustomizations = (
+//   result: TDSExecutionResult,
+//   columnName: string,
+// ): object => {
+//   const columnType = result.builder.columns.find(
+//     (col) => col.name === columnName,
+//   )?.type;
+//   switch (columnType) {
+//     case PRIMITIVE_TYPE.STRING:
+//       return {
+//         filter: 'agTextColumnFilter',
+//         allowedAggFuncs: ['count'],
+//       };
+//     case PRIMITIVE_TYPE.DATE:
+//     case PRIMITIVE_TYPE.DATETIME:
+//     case PRIMITIVE_TYPE.STRICTDATE:
+//       return {
+//         filter: 'agDateColumnFilter',
+//         allowedAggFuncs: ['count'],
+//       };
+//     case PRIMITIVE_TYPE.DECIMAL:
+//     case PRIMITIVE_TYPE.INTEGER:
+//     case PRIMITIVE_TYPE.FLOAT:
+//       return {
+//         filter: 'agNumberColumnFilter',
+//         allowedAggFuncs: ['count', 'sum', 'max', 'min', 'avg'],
+//       };
+//     default:
+//       return {
+//         allowedAggFuncs: ['count'],
+//       };
+//   }
+// };
+
+// TODO: @akphi - do we need a default column definition?
+// export const getDefaultColumnDefintions = (): object => ({
+//   minWidth: 50,
+//   sortable: true,
+//   flex: 1,
+//   resizable: true,
+//   enableRowGroup: true,
+//   allowedAggFuncs: ['count', 'sum', 'max', 'min', 'avg'],
+//   enableValue: true,
+//   menuTabs: ['filterMenuTab', 'generalMenuTab', 'columnsMenuTab'],
+// });
+
+// export const getTDSRowData = (tds: TabularDataSet): TDSRowDataType[] =>
+//   tds.rows.map((_row, rowIdx) => {
+//     const row: TDSRowDataType = {};
+//     const cols = tds.columns;
+//     _row.values.forEach((value, colIdx) => {
+//       // `ag-grid` shows `false` value as empty string so we have
+//       // call `.toString()` to avoid this behavior.
+//       row[cols[colIdx] as string] = isBoolean(value) ? String(value) : value;
+//     });
+//     row.rowNumber = rowIdx;
+//     return row;
+//   });
+
+function buildColumnSortSpecification(
+  colName: string,
+  snapshot: DataCubeQuerySnapshot,
+) {
+  const sortCol = snapshot.sortColumns.find((c) => c.name === colName);
+  if (!sortCol) {
+    return {
+      sort: null,
+      sortIndex: null,
+    };
+  }
+  return {
+    sort:
+      sortCol.direction === DATA_CUBE_COLUMN_SORT_DIRECTION.ASCENDING
+        ? GridClientSortDirection.ASCENDING
+        : GridClientSortDirection.DESCENDING,
+    sortIndex: snapshot.sortColumns.indexOf(sortCol),
+  };
+}
+
+export function generateGridOptionsFromSnapshot(
+  snapshot: DataCubeQuerySnapshot,
+): GridOptions {
+  const gridOptions: GridOptions = {
+    columnDefs: snapshot.columns.map((col) => ({
+      headerName: col.name,
+      field: col.name,
+      ...buildColumnSortSpecification(col.name, snapshot),
+
+      // configurable
+      minWidth: 50,
+      sortable: true,
+      flex: 1,
+      resizable: true,
+      // enableRowGroup: true,
+      // allowedAggFuncs: ['count', 'sum', 'max', 'min', 'avg'],
+      // enableValue: true,
+      // menuTabs: ['filterMenuTab', 'generalMenuTab', 'columnsMenuTab'],
+    })),
+  };
+  return gridOptions;
+}