@finos/legend-application-repl 0.0.21 → 0.0.23

package/src/components/grid/GridUtils.ts

@@ -1,220 +0,0 @@
-/**
- * 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 TDSRequest,
-  TDS_AGGREGATION_FUNCTION,
-  TDS_FILTER_OPERATION,
-  TDS_SORT_ORDER,
-} from './TDSRequest.js';
-import {
-  type TDSExecutionResult,
-  type TabularDataSet,
-  PRIMITIVE_TYPE,
-} from '@finos/legend-graph';
-import { isBoolean } from '@finos/legend-shared';
-
-export type TDSResultCellDataType =
-  | string
-  | number
-  | boolean
-  | null
-  | undefined;
-
-export interface TDSRowDataType {
-  [key: string]: TDSResultCellDataType;
-}
-
-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'],
-      };
-  }
-};
-
-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;
-  });

package/src/components/grid/ServerSideDataSource.ts

@@ -1,197 +0,0 @@
-/**
- * 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 {
-  FilterModel,
-  IServerSideDatasource,
-  IServerSideGetRowsParams,
-} from '@ag-grid-community/core';
-import {
-  TDSGroupby,
-  TDSAggregation,
-  TDSFilter,
-  TDSRequest,
-  TDSSort,
-  TDSFilterCondition,
-  TDS_FILTER_GROUP,
-  TDSColumn,
-} from './TDSRequest.js';
-import {
-  guaranteeNonNullable,
-  type GeneratorFn,
-  assertErrorThrown,
-  LogEvent,
-} from '@finos/legend-shared';
-import { LEGEND_REPL_EVENT } from '../../Const.js';
-import {
-  type TDSRowDataType,
-  getTDSRowData,
-  getTDSSortOrder,
-  getTDSFilterOperation,
-  getAggregationFunction,
-  getFilterColumnType,
-} from './GridUtils.js';
-import type { REPLGridClientStore } from '../../stores/REPLGridClientStore.js';
-import { flow, flowResult, makeObservable } from 'mobx';
-import type { INTERNAL__TDSColumn, PRIMITIVE_TYPE } from '@finos/legend-graph';
-
-export class ServerSideDataSource implements IServerSideDatasource {
-  executions = 0;
-  rowData: TDSRowDataType[] = [];
-  columns: INTERNAL__TDSColumn[] = [];
-  editorStore?: REPLGridClientStore | undefined;
-
-  constructor(
-    rowData?: TDSRowDataType[] | undefined,
-    columns?: INTERNAL__TDSColumn[] | undefined,
-    editorStore?: REPLGridClientStore | undefined,
-  ) {
-    makeObservable(this, {
-      fetchRows: flow,
-    });
-    this.rowData = rowData ?? [];
-    this.columns = columns ?? [];
-    this.editorStore = editorStore;
-  }
-
-  *fetchRows(
-    params: IServerSideGetRowsParams<unknown, unknown>,
-  ): GeneratorFn<void> {
-    try {
-      if (
-        this.executions > 0 ||
-        this.editorStore?.dataCubeState.gridState.currentQueryTDSRequest
-      ) {
-        if (this.editorStore) {
-          const request = this.extractRequest(params);
-          this.editorStore.dataCubeState.gridState.setLastQueryTDSRequest(
-            request,
-          );
-          if (request) {
-            yield flowResult(
-              this.editorStore.dataCubeState.getREPLGridServerResult(request),
-            );
-            const result =
-              this.editorStore.dataCubeState.gridState.currentResult;
-            const rowData = getTDSRowData(guaranteeNonNullable(result).result);
-            params.success({ rowData: rowData });
-          } else {
-            params.fail();
-          }
-        }
-        this.editorStore?.dataCubeState.gridState.setCurrentQueryTDSRequest(
-          undefined,
-        );
-      } else {
-        params.success({ rowData: this.rowData });
-      }
-      this.executions++;
-    } catch (error) {
-      assertErrorThrown(error);
-      this.editorStore?.applicationStore.notificationService.notifyError(error);
-      this.editorStore?.applicationStore.logService.error(
-        LogEvent.create(LEGEND_REPL_EVENT.FETCH_TDS_FAILURE),
-        error,
-      );
-    }
-  }
-
-  getRows(params: IServerSideGetRowsParams<unknown, unknown>): void {
-    this.fetchRows(params);
-  }
-
-  extractRequest(
-    params: IServerSideGetRowsParams<unknown, unknown>,
-  ): TDSRequest | undefined {
-    try {
-      const request = params.request;
-      const startRow = request.startRow;
-      const endRow = request.endRow;
-      const columns = params.columnApi.getColumns()?.map((c) => c.getColId());
-      const sort = request.sortModel.map(
-        (i) => new TDSSort(i.colId, getTDSSortOrder(i.sort)),
-      );
-      const aggregations = request.valueCols.map((v) => {
-        const colType = this.columns.find((c) => c.name === v.field)?.type;
-        return new TDSAggregation(
-          guaranteeNonNullable(v.field),
-          colType as PRIMITIVE_TYPE,
-          getAggregationFunction(guaranteeNonNullable(v.aggFunc)),
-        );
-      });
-      const groupBy = new TDSGroupby(
-        request.rowGroupCols.map((r) => r.id),
-        request.groupKeys,
-        aggregations,
-      );
-      const filter: TDSFilter[] = [];
-      const filterModel = request.filterModel as FilterModel | null;
-      if (filterModel) {
-        Object.keys(filterModel).forEach((key) => {
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-          const item = filterModel[key];
-          const conditions: TDSFilterCondition[] = [];
-          const colType = getFilterColumnType(item.filterType);
-          if (item.filter === undefined && item.conditions) {
-            item.conditions.forEach(
-              (condition: { type: string; filter: unknown }) =>
-                conditions.push(
-                  new TDSFilterCondition(
-                    getTDSFilterOperation(condition.type),
-                    condition.filter,
-                  ),
-                ),
-            );
-          } else {
-            conditions.push(
-              new TDSFilterCondition(
-                getTDSFilterOperation(item.type),
-                item.filter,
-              ),
-            );
-          }
-          filter.push(
-            new TDSFilter(
-              key,
-              colType,
-              conditions,
-              item.operator === 'OR'
-                ? TDS_FILTER_GROUP.OR
-                : TDS_FILTER_GROUP.AND,
-            ),
-          );
-        });
-      }
-      const tdsRequest = new TDSRequest(
-        columns?.map((col) => new TDSColumn(col)) ?? [],
-        filter,
-        sort,
-        groupBy,
-        startRow,
-        endRow,
-      );
-      return tdsRequest;
-    } catch (error) {
-      assertErrorThrown(error);
-      this.editorStore?.applicationStore.notificationService.notifyError(error);
-      this.editorStore?.applicationStore.logService.error(
-        LogEvent.create(LEGEND_REPL_EVENT.BUILD_TDS_EQUEST_FAILURE),
-        error,
-      );
-      return undefined;
-    }
-  }
-}