@finos/legend-application-repl 0.0.20 → 0.0.21

package/src/stores/REPLGridClientStore.ts

@@ -16,62 +16,18 @@
 
 import type { LegendREPLGridClientApplicationStore } from './LegendREPLGridClientBaseStore.js';
 import { REPLServerClient } from '../server/REPLServerClient.js';
-import {
-  NetworkClient,
-  type GeneratorFn,
-  type PlainObject,
-  assertErrorThrown,
-  LogEvent,
-  guaranteeNonNullable,
-  guaranteeType,
-  ActionState,
-  HttpStatus,
-  NetworkClientError,
-} from '@finos/legend-shared';
-import type { TDSRequest } from '../components/grid/TDSRequest.js';
-import { flow, flowResult, makeObservable, observable } from 'mobx';
-import { REPLGridServerResult } from '../components/grid/REPLGridServerResult.js';
-import {
-  LEGEND_APPLICATION_REPL_SETTING_KEY,
-  LEGEND_REPL_EVENT,
-} from '../Const.js';
-import { REPLGridState } from './REPLGridState.js';
-import { buildLambdaExpressions } from '../components/grid/TDSLambdaBuilder.js';
-import {
-  type V1_TDSExecutionResult,
-  TDSExecutionResult,
-  V1_Lambda,
-  V1_buildExecutionResult,
-  V1_deserializeValueSpecification,
-  V1_serializeExecutionResult,
-  V1_serializeValueSpecification,
-  V1_ParserError,
-  ParserError,
-  SourceInformation,
-} from '@finos/legend-graph';
-import { CompletionItem } from './CompletionResult.js';
-import {
-  languages as monacoLanguagesAPI,
-  type IPosition,
-  type editor as monacoEditorAPI,
-} from 'monaco-editor';
+import { NetworkClient } from '@finos/legend-shared';
+import { makeObservable, observable } from 'mobx';
+import { DataCubeState } from './dataCube/DataCubeState.js';
 
 export class REPLGridClientStore {
   readonly applicationStore: LegendREPLGridClientApplicationStore;
   readonly client: REPLServerClient;
-  replGridState!: REPLGridState;
-  executeAction = ActionState.create();
+  dataCubeState!: DataCubeState;
 
   constructor(applicationStore: LegendREPLGridClientApplicationStore) {
     makeObservable(this, {
-      replGridState: observable,
-      executeAction: observable,
-      getREPLGridServerResult: flow,
-      getInitialQueryLambda: flow,
-      getInitialREPLGridServerResult: flow,
-      getLicenseKey: flow,
-      executeLambda: flow,
-      parseQuery: flow,
+      dataCubeState: observable,
     });
     this.applicationStore = applicationStore;
     this.client = new REPLServerClient(
@@ -82,204 +38,6 @@ export class REPLGridClientStore {
           : this.applicationStore.config.replUrl,
       }),
     );
-    const isPaginationEnabled =
-      applicationStore.settingService.getBooleanValue(
-        LEGEND_APPLICATION_REPL_SETTING_KEY.PAGINATION,
-      ) ?? true;
-    this.replGridState = new REPLGridState(isPaginationEnabled);
-  }
-
-  *getREPLGridServerResult(tdsRequest: TDSRequest): GeneratorFn<void> {
-    try {
-      const isSubQuery = tdsRequest.groupBy.groupKeys.length !== 0;
-      const lambda = buildLambdaExpressions(
-        guaranteeNonNullable(this.replGridState.initialQueryLambda?.body[0]),
-        tdsRequest,
-        this.replGridState.isPaginationEnabled,
-      );
-      const resultObj = (yield flowResult(
-        this.client.getREPLGridServerResult(
-          V1_serializeValueSpecification(lambda, []),
-        ),
-      )) as PlainObject<REPLGridServerResult>;
-      const replGridResult =
-        REPLGridServerResult.serialization.fromJson(resultObj);
-      const tdsResult = JSON.parse(
-        replGridResult.result,
-      ) as PlainObject<V1_TDSExecutionResult>;
-      this.replGridState.setCurrentResult(
-        guaranteeType(
-          V1_buildExecutionResult(V1_serializeExecutionResult(tdsResult)),
-          TDSExecutionResult,
-        ),
-      );
-      if (isSubQuery) {
-        this.replGridState.setCurrentSubQuery(replGridResult.currentQuery);
-      } else {
-        this.replGridState.queryEditorState.setQuery(
-          replGridResult.currentQuery.substring(1),
-        );
-        this.replGridState.setCurrentSubQuery(undefined);
-      }
-    } catch (error) {
-      assertErrorThrown(error);
-      this.applicationStore.notificationService.notifyError(error);
-      this.applicationStore.logService.error(
-        LogEvent.create(LEGEND_REPL_EVENT.FETCH_TDS_FAILURE),
-        error,
-      );
-    }
-  }
-
-  async getTypeaheadResults(
-    position: IPosition,
-    model: monacoEditorAPI.ITextModel,
-  ): Promise<monacoLanguagesAPI.CompletionItem[]> {
-    try {
-      const textUntilPosition = model.getValueInRange({
-        startLineNumber: 1,
-        startColumn: 1,
-        endLineNumber: position.lineNumber,
-        endColumn: position.column,
-      });
-      const resultObj =
-        await this.client.getTypeaheadResults(textUntilPosition);
-      const result = resultObj.map((res) =>
-        CompletionItem.serialization.fromJson(res),
-      );
-      const currentWord = model.getWordUntilPosition(position);
-      return result.map((res) => ({
-        label: res.display,
-        kind: monacoLanguagesAPI.CompletionItemKind.Text,
-        range: {
-          startLineNumber: position.lineNumber,
-          startColumn: currentWord.startColumn + 1,
-          endLineNumber: position.lineNumber,
-          endColumn: currentWord.endColumn + 1,
-        },
-        insertText: res.completion,
-      })) as monacoLanguagesAPI.CompletionItem[];
-    } catch (e) {
-      return [];
-    }
-  }
-
-  *executeLambda(): GeneratorFn<void> {
-    try {
-      this.executeAction.inProgress();
-      const resultObj = (yield this.client.executeLambda(
-        this.replGridState.queryEditorState.query,
-        this.replGridState.isPaginationEnabled,
-      )) as PlainObject<REPLGridServerResult>;
-      const replGridResult =
-        REPLGridServerResult.serialization.fromJson(resultObj);
-      const tdsResultObj = JSON.parse(
-        replGridResult.result,
-      ) as PlainObject<V1_TDSExecutionResult>;
-      const tdsResult = guaranteeType(
-        V1_buildExecutionResult(V1_serializeExecutionResult(tdsResultObj)),
-        TDSExecutionResult,
-      );
-      this.replGridState.setInitialResult(tdsResult);
-      this.replGridState.queryEditorState.setQuery(
-        replGridResult.currentQuery.substring(1),
-      );
-      this.replGridState.setCurrentSubQuery(undefined);
-      this.replGridState.setColumns(tdsResult.result.columns);
-
-      yield flowResult(this.getInitialQueryLambda());
-      this.executeAction.complete();
-    } catch (error) {
-      this.executeAction.fail();
-      assertErrorThrown(error);
-      this.applicationStore.notificationService.notifyError(error);
-      this.applicationStore.logService.error(
-        LogEvent.create(LEGEND_REPL_EVENT.FETCH_TDS_FAILURE),
-        error,
-      );
-    }
-  }
-
-  *parseQuery(): GeneratorFn<void> {
-    try {
-      this.replGridState.queryEditorState.setParserError(undefined);
-      yield flowResult(
-        this.client.parseQuery(`|${this.replGridState.queryEditorState.query}`),
-      );
-    } catch (error) {
-      assertErrorThrown(error);
-      if (
-        error instanceof NetworkClientError &&
-        error.response.status === HttpStatus.BAD_REQUEST
-      ) {
-        const protocol = V1_ParserError.serialization.fromJson(
-          error.payload as PlainObject<V1_ParserError>,
-        );
-        const parserError = new ParserError(protocol.message);
-        if (protocol.sourceInformation) {
-          parserError.sourceInformation = new SourceInformation(
-            protocol.sourceInformation.sourceId,
-            protocol.sourceInformation.startLine,
-            protocol.sourceInformation.startColumn,
-            protocol.sourceInformation.endLine,
-            protocol.sourceInformation.endColumn,
-          );
-        }
-        this.replGridState.queryEditorState.setParserError(parserError);
-      }
-    }
-  }
-
-  *getInitialQueryLambda(): GeneratorFn<void> {
-    const lambdaObj =
-      (yield this.client.getIntialQueryLambda()) as PlainObject<V1_Lambda>;
-    const lambda = V1_deserializeValueSpecification(lambdaObj, []);
-    if (lambda instanceof V1_Lambda) {
-      this.replGridState.setInitialQueryLambda(lambda);
-    }
-  }
-
-  *getInitialREPLGridServerResult(): GeneratorFn<void> {
-    try {
-      this.executeAction.inProgress();
-      if (!this.replGridState.licenseKey) {
-        yield flowResult(this.getLicenseKey());
-      }
-
-      yield flowResult(this.getInitialQueryLambda());
-
-      const resultObj = (yield this.client.getInitialREPLGridServerResult(
-        this.replGridState.isPaginationEnabled,
-      )) as PlainObject<REPLGridServerResult>;
-      const replGridResult =
-        REPLGridServerResult.serialization.fromJson(resultObj);
-      const tdsResultObj = JSON.parse(
-        replGridResult.result,
-      ) as PlainObject<V1_TDSExecutionResult>;
-      const tdsResult = guaranteeType(
-        V1_buildExecutionResult(V1_serializeExecutionResult(tdsResultObj)),
-        TDSExecutionResult,
-      );
-      this.replGridState.setInitialResult(tdsResult);
-      this.replGridState.queryEditorState.setQuery(
-        replGridResult.currentQuery.substring(1),
-      );
-      this.replGridState.setCurrentSubQuery(undefined);
-      this.replGridState.setColumns(tdsResult.result.columns);
-      this.executeAction.complete();
-    } catch (error) {
-      this.executeAction.fail();
-      assertErrorThrown(error);
-      this.applicationStore.notificationService.notifyError(error);
-      this.applicationStore.logService.error(
-        LogEvent.create(LEGEND_REPL_EVENT.FETCH_TDS_FAILURE),
-        error,
-      );
-    }
-  }
-
-  *getLicenseKey(): GeneratorFn<void> {
-    const licenseKey = (yield this.client.getLicenseKey()) as string;
-    this.replGridState.setLicenseKey(licenseKey);
+    this.dataCubeState = new DataCubeState(this);
   }
 }

package/src/stores/dataCube/DataCubeConfigState.ts

@@ -0,0 +1,79 @@
+/**
+ * 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 { GridApi } from '@ag-grid-community/core';
+import type { DataCubeState } from './DataCubeState.js';
+import { LEGEND_APPLICATION_REPL_SETTING_KEY } from '../../Const.js';
+
+export class DataCubeConfigState {
+  readonly dataCubeState!: DataCubeState;
+
+  licenseKey?: string | undefined;
+  isPaginationEnabled!: boolean;
+  gridApi?: GridApi | undefined;
+
+  isPivotPanelOpened = false;
+
+  constructor(dataCubeState: DataCubeState) {
+    makeObservable(this, {
+      licenseKey: observable,
+      isPaginationEnabled: observable,
+      gridApi: observable,
+      isPivotPanelOpened: observable,
+      setGridApi: action,
+      setLicenseKey: action,
+      setIsPaginationEnabled: action,
+      setIsPivotPanelOpened: action,
+      openPanel: action,
+      closePanel: action,
+    });
+
+    this.dataCubeState = dataCubeState;
+    this.isPaginationEnabled =
+      dataCubeState.editorStore.applicationStore.settingService.getBooleanValue(
+        LEGEND_APPLICATION_REPL_SETTING_KEY.PAGINATION,
+      ) ?? true;
+  }
+
+  setIsPivotPanelOpened(val: boolean): void {
+    this.isPivotPanelOpened = val;
+  }
+
+  setGridApi(val: GridApi | undefined): void {
+    this.gridApi = val;
+  }
+
+  setLicenseKey(val: string | undefined): void {
+    this.licenseKey = val;
+  }
+
+  setIsPaginationEnabled(val: boolean): void {
+    this.isPaginationEnabled = val;
+  }
+
+  openPanel(): void {
+    this.dataCubeState.configState.setIsPivotPanelOpened(true);
+    this.dataCubeState.propertiesPanelState.hpivotAndSortPanelState.initialize();
+  }
+
+  closePanel(): void {
+    this.dataCubeState.configState.setIsPivotPanelOpened(false);
+    this.dataCubeState.propertiesPanelState.hpivotAndSortPanelState.setIsInitialized(
+      false,
+    );
+  }
+}

package/src/stores/{REPLGridState.ts → dataCube/DataCubeGridState.ts}

@@ -17,55 +17,65 @@
 import { guaranteeNonNullable } from '@finos/legend-shared';
 import {
   getAggregationTDSColumnCustomizations,
+  getFilterModeltype,
+  getTDSColumnCustomizations,
   getTDSRowData,
   type TDSRowDataType,
-} from '../components/grid/GridUtils.js';
+} from '../../components/grid/GridUtils.js';
 import { action, computed, makeObservable, observable } from 'mobx';
 import type { ColDef } from '@ag-grid-community/core';
 import type { V1_Lambda, TDSExecutionResult } from '@finos/legend-graph';
-import { QueryEditorState } from '../components/REPLQueryEditor.js';
+import {
+  TDS_FILTER_GROUP,
+  type TDSRequest,
+} from '../../components/grid/TDSRequest.js';
+import type { DataCubeState } from './DataCubeState.js';
+
+interface FilterModel {
+  [key: string]: object;
+}
+
+export class DataCubeGridState {
+  readonly dataCubeState!: DataCubeState;
 
-export class REPLGridState {
   initialResult?: TDSExecutionResult | undefined;
   currentResult?: TDSExecutionResult | undefined;
   columns?: string[] | undefined;
-  queryEditorState: QueryEditorState;
-  currentSubQuery?: string | undefined;
-  licenseKey?: string | undefined;
   initialQueryLambda?: V1_Lambda | undefined;
-  isPaginationEnabled!: boolean;
+  currentQueryTDSRequest?: TDSRequest | undefined;
+  lastQueryTDSRequest?: TDSRequest | undefined;
 
-  constructor(isPaginationEnabled: boolean) {
+  constructor(dataCubeState: DataCubeState) {
     makeObservable(this, {
       initialResult: observable,
       initialQueryLambda: observable,
       currentResult: observable,
-      currentSubQuery: observable,
-      licenseKey: observable,
       columns: observable,
-      isPaginationEnabled: observable,
-      queryEditorState: observable,
+      currentQueryTDSRequest: observable,
+      lastQueryTDSRequest: observable,
       setInitialResult: action,
-      setCurrentSubQuery: action,
       setColumns: action,
       setInitialQueryLambda: action,
       setCurrentResult: action,
-      setLicenseKey: action,
-      setIsPaginationEnabled: action,
+      setCurrentQueryTDSRequest: action,
+      setLastQueryTDSRequest: action,
       rowData: computed,
       columnDefs: computed,
     });
 
-    this.queryEditorState = new QueryEditorState('');
-    this.isPaginationEnabled = isPaginationEnabled;
+    this.dataCubeState = dataCubeState;
   }
 
-  setInitialQueryLambda(val: V1_Lambda | undefined): void {
-    this.initialQueryLambda = val;
+  setLastQueryTDSRequest(val: TDSRequest | undefined): void {
+    this.lastQueryTDSRequest = val;
+  }
+
+  setCurrentQueryTDSRequest(val: TDSRequest | undefined): void {
+    this.currentQueryTDSRequest = val;
   }
 
-  setCurrentSubQuery(val: string | undefined): void {
-    this.currentSubQuery = val;
+  setInitialQueryLambda(val: V1_Lambda | undefined): void {
+    this.initialQueryLambda = val;
   }
 
   setInitialResult(val: TDSExecutionResult | undefined): void {
@@ -80,28 +90,53 @@ export class REPLGridState {
     this.columns = val;
   }
 
-  setLicenseKey(val: string | undefined): void {
-    this.licenseKey = val;
-  }
-
-  setIsPaginationEnabled(val: boolean): void {
-    this.isPaginationEnabled = val;
-  }
-
   get rowData(): TDSRowDataType[] {
     return this.initialResult ? getTDSRowData(this.initialResult.result) : [];
   }
 
   get columnDefs(): ColDef[] {
+    const filterModel: FilterModel = {};
+    this.currentQueryTDSRequest?.filter.forEach((filter) => {
+      if (filter.conditions.length === 1) {
+        filterModel[filter.column] = {
+          filter: filter.conditions[0]?.value,
+          filterType: getFilterModeltype(filter.columnType),
+          type: filter.conditions[0]?.operation,
+        };
+      } else {
+        filterModel[filter.column] = {
+          filterType: getFilterModeltype(filter.columnType),
+          operator:
+            filter.groupOperation === TDS_FILTER_GROUP.AND ? 'AND' : 'OR',
+          condition1: {
+            filter: filter.conditions[0]?.value,
+            filterType: getFilterModeltype(filter.columnType),
+            type: filter.conditions[0]?.operation,
+          },
+          condition2: {
+            filter: filter.conditions[1]?.value,
+            filterType: getFilterModeltype(filter.columnType),
+            type: filter.conditions[1]?.operation,
+          },
+        };
+      }
+    });
+    if (this.currentQueryTDSRequest) {
+      this.dataCubeState.configState.gridApi?.setFilterModel(filterModel);
+    }
     return this.columns
       ? this.columns.map((c) => ({
           field: c,
           headerName: c,
           ...getAggregationTDSColumnCustomizations(
-            this.licenseKey ? true : false,
             guaranteeNonNullable(this.initialResult),
             c,
           ),
+          ...getTDSColumnCustomizations(
+            guaranteeNonNullable(this.initialResult),
+            c,
+            this.currentQueryTDSRequest,
+          ),
         }))
       : [];
   }

package/src/stores/dataCube/DataCubePanelState.ts

@@ -0,0 +1,28 @@
+/**
+ * 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 { DataCubeState } from './DataCubeState.js';
+
+export abstract class DataCubePanelState {
+  readonly dataCubeState!: DataCubeState;
+
+  constructor(dataCubeState: DataCubeState) {
+    this.dataCubeState = dataCubeState;
+  }
+
+  abstract initialize(): void;
+  abstract applyChanges(): void;
+}

package/src/stores/dataCube/DataCubePropertiesPanelState.ts

@@ -0,0 +1,65 @@
+/**
+ * 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 { HPivotAndSortPanelState } from './HPivotAndSortPanelState.js';
+
+export enum PIVOT_PANEL_TABS {
+  COLUMNS_AND_PIVOTS = 'Colums/Pivots',
+  HPIVOTS_AND_SORTS = 'HPivots/Sorts',
+  GENERAL_PROPERTIES = 'General Properties',
+  COLUMN_PROPERTIES = 'Column Properties',
+  DEVELOPER_OPTIONS = 'Developer',
+  PIVOT_LAYOUT = 'Pivot Layout',
+}
+
+export class DataCubePropertiesPanelState {
+  readonly dataCubeState!: DataCubeState;
+  selectedPivotPanelTab = PIVOT_PANEL_TABS.COLUMNS_AND_PIVOTS;
+  hpivotAndSortPanelState!: HPivotAndSortPanelState;
+
+  constructor(dataCubeState: DataCubeState) {
+    makeObservable(this, {
+      selectedPivotPanelTab: observable,
+      hpivotAndSortPanelState: observable,
+      setSelectedPivotPanelTab: action,
+      applyChanges: action,
+    });
+
+    this.dataCubeState = dataCubeState;
+    this.hpivotAndSortPanelState = new HPivotAndSortPanelState(
+      this.dataCubeState,
+    );
+  }
+
+  setSelectedPivotPanelTab(val: PIVOT_PANEL_TABS): void {
+    this.selectedPivotPanelTab = val;
+    switch (val) {
+      case PIVOT_PANEL_TABS.HPIVOTS_AND_SORTS: {
+        this.hpivotAndSortPanelState.initialize();
+        break;
+      }
+      default: {
+        return;
+      }
+    }
+  }
+
+  applyChanges(): void {
+    this.hpivotAndSortPanelState.applyChanges();
+  }
+}

package/src/stores/dataCube/DataCubeQueryEditorState.ts

@@ -0,0 +1,66 @@
+/**
+ * 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 { SourceInformation, type ParserError } from '@finos/legend-graph';
+import { uuid } from '@finos/legend-shared';
+import { action, makeObservable, observable } from 'mobx';
+
+export class DataCubeQueryEditorState {
+  uuid = uuid();
+  query: string;
+  parserError?: ParserError | undefined;
+
+  constructor(query: string) {
+    makeObservable(this, {
+      query: observable,
+      parserError: observable,
+      setQuery: action,
+      setParserError: action,
+    });
+
+    this.query = query;
+  }
+
+  setQuery(val: string): void {
+    this.query = val;
+  }
+
+  setParserError(parserError: ParserError | undefined): void {
+    // account for the lambda prefix offset in source information
+    if (parserError?.sourceInformation) {
+      parserError.sourceInformation = this.processSourceInformation(
+        parserError.sourceInformation,
+      );
+    }
+    this.parserError = parserError;
+  }
+
+  processSourceInformation(
+    sourceInformation: SourceInformation,
+  ): SourceInformation {
+    const { sourceId, startLine, startColumn, endLine, endColumn } =
+      sourceInformation;
+    const lineOffset = 0;
+    const columnOffset = 0;
+    return new SourceInformation(
+      sourceId,
+      startLine + lineOffset,
+      startColumn - (startLine === 1 ? columnOffset : 0),
+      endLine + lineOffset,
+      endColumn - (endLine === 1 ? columnOffset : 0),
+    );
+  }
+}