@finos/legend-data-cube 0.0.7 → 0.0.8

package/src/stores/{editor → view/editor}/DataCubeEditorState.tsx

@@ -17,29 +17,31 @@
 import { action, makeObservable, observable } from 'mobx';
 import type { DataCubeViewState } from '../DataCubeViewState.js';
 import { DataCubeEditorSortsPanelState } from './DataCubeEditorSortsPanelState.js';
-import { DataCubeQuerySnapshotController } from '../core/DataCubeQuerySnapshotManager.js';
+import { DataCubeQuerySnapshotController } from '../DataCubeQuerySnapshotManager.js';
 import {
   _toCol,
   type DataCubeQuerySnapshot,
   type DataCubeQuerySnapshotColumn,
   type DataCubeQuerySnapshotExtendedColumn,
-} from '../core/DataCubeQuerySnapshot.js';
+} from '../../core/DataCubeQuerySnapshot.js';
 import {
   ActionState,
   assertErrorThrown,
   guaranteeNonNullable,
+  HttpStatus,
+  NetworkClientError,
 } from '@finos/legend-shared';
 import { DataCubeEditorGeneralPropertiesPanelState } from './DataCubeEditorGeneralPropertiesPanelState.js';
 import { DataCubeEditorColumnPropertiesPanelState } from './DataCubeEditorColumnPropertiesPanelState.js';
 import { DataCubeEditorColumnsPanelState } from './DataCubeEditorColumnsPanelState.js';
-import { DataCubeConfiguration } from '../core/DataCubeConfiguration.js';
+import { DataCubeConfiguration } from '../../core/DataCubeConfiguration.js';
 import { DataCubeEditorVerticalPivotsPanelState } from './DataCubeEditorVerticalPivotsPanelState.js';
-import type { DisplayState } from '../engine/DataCubeLayoutManagerState.js';
-import { DataCubeEditor } from '../../components/editor/DataCubeEditor.js';
-import { buildExecutableQuery } from '../core/DataCubeQueryBuilder.js';
-import { _lambda } from '../core/DataCubeQueryBuilderUtils.js';
+import type { DisplayState } from '../../core/DataCubeLayoutManagerState.js';
+import { DataCubeEditor } from '../../../components/view/editor/DataCubeEditor.js';
 import { DataCubeEditorHorizontalPivotsPanelState } from './DataCubeEditorHorizontalPivotsPanelState.js';
 import { DataCubeEditorPivotLayoutPanelState } from './DataCubeEditorPivotLayoutPanelState.js';
+import type { DataCubeQueryBuilderError } from '../../core/DataCubeEngine.js';
+import { V1_deserializeValueSpecification } from '@finos/legend-graph';
 
 export enum DataCubeEditorTab {
   GENERAL_PROPERTIES = 'General Properties',
@@ -132,8 +134,11 @@ export class DataCubeEditorState extends DataCubeQuerySnapshotController {
     this.sorts.applySnaphot(snapshot, configuration);
   }
 
+  override getSnapshotSubscriberName() {
+    return 'editor';
+  }
+
   async applyChanges(options?: { closeAfterApply?: boolean | undefined }) {
-    const task = this.view.newTask('Validate query');
     this.finalizationState.inProgress();
 
     const baseSnapshot = guaranteeNonNullable(this.getLatestSnapshot());
@@ -155,46 +160,61 @@ export class DataCubeEditorState extends DataCubeQuerySnapshotController {
     // finalize
     newSnapshot.finalize();
     if (newSnapshot.hashCode !== baseSnapshot.hashCode) {
+      const task = this.view.newTask('Validate query');
       // NOTE: Compile the query to validate. This is a helpful check for a lot of different scenarios
       // where the consistency of the query might be thrown off by changes from various parts that the
       // editor does not have full control over (i.e. extended columns, pivot cast columns, etc.)
       // e.g. when a column that group-level extended columns' expressions depend on has been unselected.
+      const tempSnapshot = newSnapshot.clone();
+      // NOTE: in order to obtain the actual pivot result columns information, we need to execute
+      // the query which is expensive in certain cases, so here, we just compute the "optimistic" set
+      // of pivot result columns for casting to guarantee validation is not thronn off.
+      if (tempSnapshot.data.pivot) {
+        tempSnapshot.data.pivot.castColumns =
+          this.sorts.selector.availableColumns
+            .filter(
+              (col) =>
+                !tempSnapshot.data.groupExtendedColumns.find(
+                  (column) => column.name === col.name,
+                ),
+            )
+            .map(_toCol);
+      }
+
+      const codePrefix = `->`;
+      const code = await this.view.engine.getPartialQueryCode(
+        tempSnapshot,
+        true,
+      );
       try {
-        const tempSnapshot = newSnapshot.clone();
-        // NOTE: in order to obtain the actual pivot result columns information, we need to execute
-        // the query which is expensive in certain cases, so here, we just compute the "optimistic" set
-        // of pivot result columns for casting to guarantee validation is not thronn off.
-        if (tempSnapshot.data.pivot) {
-          tempSnapshot.data.pivot.castColumns =
-            this.sorts.selector.availableColumns
-              .filter(
-                (col) =>
-                  !tempSnapshot.data.groupExtendedColumns.find(
-                    (column) => column.name === col.name,
-                  ),
-              )
-              .map(_toCol);
-        }
-        await this.view.engine.getQueryRelationType(
-          _lambda(
-            [],
-            [
-              buildExecutableQuery(
-                tempSnapshot,
-                this.view.engine.filterOperations,
-                this.view.engine.aggregateOperations,
-              ),
-            ],
-          ),
+        await this.view.engine.getQueryCodeRelationReturnType(
+          codePrefix + code,
+          V1_deserializeValueSpecification(tempSnapshot.data.sourceQuery, []),
         );
       } catch (error) {
         assertErrorThrown(error);
-        this.view.application.alertError(error, {
-          message: `Query Validation Failure: ${error.message}`,
-        });
-        this.view.endTask(task);
+        if (
+          error instanceof NetworkClientError &&
+          error.response.status === HttpStatus.BAD_REQUEST
+        ) {
+          this.view.application.alertCodeCheckError(
+            error.payload as DataCubeQueryBuilderError,
+            code,
+            codePrefix,
+            {
+              message: `Query Validation Failure: Can't safely apply changes. Check the query code below for more details.`,
+              text: `Error: ${error.message}`,
+            },
+          );
+        } else {
+          this.view.application.alertError(error, {
+            message: `Query Validation Failure: Can't safely apply changes.`,
+            text: `Error: ${error.message}`,
+          });
+        }
         return;
       } finally {
+        this.view.endTask(task);
         this.finalizationState.complete();
       }
 
@@ -206,6 +226,5 @@ export class DataCubeEditorState extends DataCubeQuerySnapshotController {
     if (options?.closeAfterApply) {
       this.display.close();
     }
-    this.view.endTask(task);
   }
 }

package/src/stores/{editor → view/editor}/DataCubeEditorVerticalPivotsPanelState.ts

@@ -16,24 +16,24 @@
 
 import { uniqBy } from '@finos/legend-shared';
 import type { DataCubeViewState } from '../DataCubeViewState.js';
-import type { DataCubeConfiguration } from '../core/DataCubeConfiguration.js';
-import { DataCubeColumnKind } from '../core/DataCubeQueryEngine.js';
+import type { DataCubeConfiguration } from '../../core/DataCubeConfiguration.js';
+import { DataCubeColumnKind } from '../../core/DataCubeQueryEngine.js';
 import {
   _toCol,
   type DataCubeQuerySnapshot,
-} from '../core/DataCubeQuerySnapshot.js';
+} from '../../core/DataCubeQuerySnapshot.js';
 import {
-  DataCubeEditorColumnsSelectorColumnState,
-  DataCubeEditorColumnsSelectorState,
-} from './DataCubeEditorColumnsSelectorState.js';
+  DataCubeEditorColumnSelectorColumnState,
+  DataCubeEditorColumnSelectorState,
+} from './DataCubeEditorColumnSelectorState.js';
 import type { DataCubeQueryEditorPanelState } from './DataCubeEditorPanelState.js';
 import type { DataCubeEditorState } from './DataCubeEditorState.js';
 
-export class DataCubeEditorVerticalPivotColumnsSelectorState extends DataCubeEditorColumnsSelectorState<DataCubeEditorColumnsSelectorColumnState> {
+export class DataCubeEditorVerticalPivotColumnSelectorState extends DataCubeEditorColumnSelectorState<DataCubeEditorColumnSelectorColumnState> {
   override cloneColumn(
-    column: DataCubeEditorColumnsSelectorColumnState,
-  ): DataCubeEditorColumnsSelectorColumnState {
-    return new DataCubeEditorColumnsSelectorColumnState(
+    column: DataCubeEditorColumnSelectorColumnState,
+  ): DataCubeEditorColumnSelectorColumnState {
+    return new DataCubeEditorColumnSelectorColumnState(
       column.name,
       column.type,
     );
@@ -55,7 +55,7 @@ export class DataCubeEditorVerticalPivotColumnsSelectorState extends DataCubeEdi
       )
       .map(
         (col) =>
-          new DataCubeEditorColumnsSelectorColumnState(col.name, col.type),
+          new DataCubeEditorColumnSelectorColumnState(col.name, col.type),
       );
   }
 }
@@ -65,12 +65,12 @@ export class DataCubeEditorVerticalPivotsPanelState
 {
   readonly view!: DataCubeViewState;
   readonly editor!: DataCubeEditorState;
-  readonly selector!: DataCubeEditorVerticalPivotColumnsSelectorState;
+  readonly selector!: DataCubeEditorVerticalPivotColumnSelectorState;
 
   constructor(editor: DataCubeEditorState) {
     this.editor = editor;
     this.view = editor.view;
-    this.selector = new DataCubeEditorVerticalPivotColumnsSelectorState(editor);
+    this.selector = new DataCubeEditorVerticalPivotColumnSelectorState(editor);
   }
 
   adaptPropagatedChanges(): void {
@@ -88,7 +88,7 @@ export class DataCubeEditorVerticalPivotsPanelState
     this.selector.setSelectedColumns(
       (snapshot.data.groupBy?.columns ?? []).map(
         (col) =>
-          new DataCubeEditorColumnsSelectorColumnState(col.name, col.type),
+          new DataCubeEditorColumnSelectorColumnState(col.name, col.type),
       ),
     );
   }

package/src/stores/{extend → view/extend}/DataCubeColumnEditorState.tsx

@@ -14,10 +14,10 @@
  * limitations under the License.
  */
 
-import { action, computed, makeObservable, observable } from 'mobx';
+import { action, computed, makeObservable, observable, override } from 'mobx';
 import type { DataCubeViewState } from '../DataCubeViewState.js';
-import type { DisplayState } from '../engine/DataCubeLayoutManagerState.js';
-import { DataCubeColumnCreator } from '../../components/extend/DataCubeColumnEditor.js';
+import type { DisplayState } from '../../core/DataCubeLayoutManagerState.js';
+import { DataCubeColumnCreator } from '../../../components/view/extend/DataCubeColumnEditor.js';
 import { editor as monacoEditorAPI, Uri } from 'monaco-editor';
 import {
   ActionState,
@@ -26,31 +26,33 @@ import {
   HttpStatus,
   NetworkClientError,
   uuid,
+  type PlainObject,
 } from '@finos/legend-shared';
-import { buildExecutableQuery } from '../core/DataCubeQueryBuilder.js';
+import { buildExecutableQuery } from '../../core/DataCubeQueryBuilder.js';
 import {
   DataCubeColumnDataType,
   DataCubeColumnKind,
-  DataCubeExtendedColumnType,
   DEFAULT_LAMBDA_VARIABLE_NAME,
   getDataType,
-} from '../core/DataCubeQueryEngine.js';
+} from '../../core/DataCubeQueryEngine.js';
 import {
   clearMarkers,
   CODE_EDITOR_LANGUAGE,
   setErrorMarkers,
 } from '@finos/legend-code-editor';
-import type { DataCubeQueryBuilderError } from '../engine/DataCubeEngine.js';
+import type { DataCubeQueryBuilderError } from '../../core/DataCubeEngine.js';
 import type { DataCubeExtendManagerState } from './DataCubeExtendManagerState.js';
 import {
   PRIMITIVE_TYPE,
+  V1_deserializeValueSpecification,
   V1_Lambda,
   V1_serializeValueSpecification,
   type V1_ValueSpecification,
 } from '@finos/legend-graph';
-import type { DataCubeColumnConfiguration } from '../core/DataCubeConfiguration.js';
+import type { DataCubeColumnConfiguration } from '../../core/DataCubeConfiguration.js';
+import type { DataCubeQuerySnapshotExtendedColumn } from '../../core/DataCubeQuerySnapshot.js';
 
-export class DataCubeNewColumnState {
+export abstract class DataCubeColumnBaseEditorState {
   readonly uuid = uuid();
   readonly view: DataCubeViewState;
   readonly manager: DataCubeExtendManagerState;
@@ -67,7 +69,7 @@ export class DataCubeNewColumnState {
   isGroupLevel: boolean;
   columnKind?: DataCubeColumnKind | undefined;
 
-  code: string;
+  code = '';
   codePrefix: string;
   codeSuffix: string;
 
@@ -79,7 +81,10 @@ export class DataCubeNewColumnState {
 
   constructor(
     manager: DataCubeExtendManagerState,
-    referenceColumn?: DataCubeColumnConfiguration | undefined,
+    name: string,
+    expectedType: string,
+    isGroupLevel: boolean,
+    columnKind: DataCubeColumnKind | undefined,
   ) {
     makeObservable(this, {
       name: observable,
@@ -107,43 +112,35 @@ export class DataCubeNewColumnState {
 
     this.manager = manager;
     this.view = manager.view;
-    this.display = this.view.application.layout.newDisplay(
-      'Add New Column',
-      () => <DataCubeColumnCreator state={this} />,
-      {
-        x: 50,
-        y: 50,
-        width: 500,
-        height: 300,
-        minWidth: 300,
-        minHeight: 200,
-        center: false,
-      },
-    );
+    this.display = this.newDisplay(this);
 
-    this.name = `col_${manager.allColumnNames.length + 1}`;
-    this.expectedType = DataCubeColumnDataType.NUMBER;
-    this.isGroupLevel = false;
-    this.columnKind = DataCubeColumnKind.MEASURE;
+    this.name = name;
+    this.expectedType = expectedType;
+    this.isGroupLevel = isGroupLevel;
+    this.columnKind = columnKind;
 
-    this.code = `${DEFAULT_LAMBDA_VARIABLE_NAME}|`;
     this.codePrefix = `->extend(~${this._name}:`;
     this.codeSuffix = `)`;
 
-    if (referenceColumn) {
-      this.expectedType = getDataType(referenceColumn.type);
-      this.columnKind = referenceColumn.kind;
-      this.code = `${DEFAULT_LAMBDA_VARIABLE_NAME}|$${DEFAULT_LAMBDA_VARIABLE_NAME}.${referenceColumn.name}`;
-    }
-
     this.editorModelUri = Uri.file(`/${this.uuid}.pure`);
     this.editorModel = monacoEditorAPI.createModel(
-      this.code,
+      '',
       CODE_EDITOR_LANGUAGE.PURE,
       this.editorModelUri,
     );
   }
 
+  abstract getInitialCode(): Promise<string>;
+
+  async initialize() {
+    this.code = await this.getInitialCode();
+    this.editorModel.setValue(this.code);
+  }
+
+  protected abstract newDisplay(
+    state: DataCubeColumnBaseEditorState,
+  ): DisplayState;
+
   setName(value: string) {
     this.name = value;
   }
@@ -171,10 +168,6 @@ export class DataCubeNewColumnState {
     this.columnKind = columnKind;
   }
 
-  setCode(value: string) {
-    this.code = value;
-  }
-
   setEditor(editor: monacoEditorAPI.IStandaloneCodeEditor) {
     this.editor = editor;
   }
@@ -298,7 +291,60 @@ export class DataCubeNewColumnState {
     return undefined;
   }
 
-  async applyChanges() {
+  abstract applyChanges(): Promise<void>;
+
+  close() {
+    // dispose the editor and its model to avoid memory leak
+    this.editorModel.dispose();
+    this.editor?.dispose();
+
+    this.display.close();
+  }
+}
+
+export class DataCubeNewColumnState extends DataCubeColumnBaseEditorState {
+  private initialCode: string;
+
+  constructor(
+    manager: DataCubeExtendManagerState,
+    referenceColumn?: DataCubeColumnConfiguration | undefined,
+  ) {
+    super(
+      manager,
+      `col_${manager.allColumnNames.length + 1}`,
+      referenceColumn
+        ? getDataType(referenceColumn.type)
+        : DataCubeColumnDataType.NUMBER,
+      false,
+      referenceColumn ? referenceColumn.kind : DataCubeColumnKind.MEASURE,
+    );
+
+    this.initialCode = referenceColumn
+      ? `${DEFAULT_LAMBDA_VARIABLE_NAME}|$${DEFAULT_LAMBDA_VARIABLE_NAME}.${referenceColumn.name}`
+      : `${DEFAULT_LAMBDA_VARIABLE_NAME}|`;
+  }
+
+  override async getInitialCode(): Promise<string> {
+    return this.initialCode;
+  }
+
+  override newDisplay(state: DataCubeColumnBaseEditorState): DisplayState {
+    return this.view.application.layout.newDisplay(
+      'Add New Column',
+      () => <DataCubeColumnCreator state={this} />,
+      {
+        x: 50,
+        y: 50,
+        width: 500,
+        height: 300,
+        minWidth: 300,
+        minHeight: 200,
+        center: false,
+      },
+    );
+  }
+
+  override async applyChanges() {
     if (
       !this.validationState.hasCompleted ||
       !this.isNameValid ||
@@ -342,10 +388,9 @@ export class DataCubeNewColumnState {
 
     this.manager.addNewColumn(
       {
-        _type: DataCubeExtendedColumnType.SIMPLE,
         name: this.name,
         type: returnType,
-        lambda: V1_serializeValueSpecification(query, []),
+        mapFn: V1_serializeValueSpecification(query, []),
       },
       this.isGroupLevel,
       this.columnKind,
@@ -354,12 +399,127 @@ export class DataCubeNewColumnState {
 
     this.close();
   }
+}
 
-  close() {
-    // dispose the editor and its model to avoid memory leak
-    this.editorModel.dispose();
-    this.editor?.dispose();
+export class DataCubeExistingColumnEditorState extends DataCubeColumnBaseEditorState {
+  readonly initialData: {
+    name: string;
+    type: string;
+    kind: DataCubeColumnKind;
+    isGroupLevel: boolean;
+    mapFn: PlainObject<V1_Lambda>;
+  };
 
-    this.display.close();
+  constructor(
+    manager: DataCubeExtendManagerState,
+    column: DataCubeQuerySnapshotExtendedColumn,
+    kind: DataCubeColumnKind,
+    isGroupLevel: boolean,
+  ) {
+    super(manager, column.name, getDataType(column.type), isGroupLevel, kind);
+
+    makeObservable(this, {
+      initialData: observable.ref,
+      isNameValid: override,
+    });
+
+    this.initialData = {
+      name: column.name,
+      type: column.type,
+      kind,
+      isGroupLevel: isGroupLevel,
+      mapFn: column.mapFn,
+    };
+  }
+
+  override get isNameValid(): boolean {
+    return !this.manager.allColumnNames
+      .filter((colName) => colName !== this.initialData.name)
+      .includes(this.name);
+  }
+
+  override async getInitialCode(): Promise<string> {
+    return this.view.engine.getQueryCode(
+      V1_deserializeValueSpecification(this.initialData.mapFn, []),
+      true,
+    );
+  }
+
+  override newDisplay(state: DataCubeColumnBaseEditorState): DisplayState {
+    return this.view.application.layout.newDisplay(
+      'Edit Column',
+      () => <DataCubeColumnCreator state={this} />,
+      {
+        x: 50,
+        y: 50,
+        width: 500,
+        height: 300,
+        minWidth: 300,
+        minHeight: 200,
+        center: false,
+      },
+    );
+  }
+
+  async reset() {
+    this.setName(this.initialData.name);
+    this.setExpectedType(getDataType(this.initialData.type));
+    this.setColumnKind(this.initialData.isGroupLevel, this.initialData.kind);
+    await this.initialize();
+    await this.getReturnType();
+  }
+
+  override async applyChanges() {
+    if (
+      !this.validationState.hasCompleted ||
+      !this.isNameValid ||
+      !this.isTypeValid
+    ) {
+      return;
+    }
+
+    this.finalizationState.inProgress();
+
+    let query: V1_ValueSpecification;
+    let returnType: string | undefined;
+    try {
+      [query, returnType] = await Promise.all([
+        this.view.engine.parseQuery(this.code, false),
+        this.getReturnType(), // recompile to get the return type
+      ]);
+    } catch (error) {
+      assertErrorThrown(error);
+      this.view.application.alertError(error, {
+        message: `Expression Validation Failure: ${error.message}`,
+      });
+      return;
+    } finally {
+      this.finalizationState.complete();
+    }
+
+    if (!(query instanceof V1_Lambda)) {
+      this.view.application.alertError(new Error(), {
+        message: `Expression Validation Failure: Expression must be a lambda.`,
+      });
+      return;
+    }
+
+    if (!returnType) {
+      this.view.application.alertError(new Error(), {
+        message: `Expression Validation Failure: Can't compute expression return type.`,
+      });
+      return;
+    }
+
+    await this.manager.updateColumn(
+      this.initialData.name,
+      {
+        name: this.name,
+        type: returnType,
+        mapFn: V1_serializeValueSpecification(query, []),
+      },
+      this.isGroupLevel,
+      this.columnKind,
+    );
   }
 }