@finos/legend-data-cube 0.1.5 → 0.1.7

package/src/components/view/grid/DataCubeMultidimensionalGrid.tsx

@@ -0,0 +1,24 @@
+/**
+ * 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 { observer } from 'mobx-react-lite';
+import type { DataCubeViewState } from '../../../stores/view/DataCubeViewState.js';
+
+export const DataCubeMultidimensionalGrid = observer(
+  (props: { view: DataCubeViewState }) => {
+    return null;
+  },
+);

package/src/stores/core/DataCubeEngine.tsx

@@ -22,6 +22,7 @@ import {
   PRIMITIVE_TYPE,
   V1_deserializeValueSpecification,
   V1_serializeValueSpecification,
+  type V1_ExecuteInput,
 } from '@finos/legend-graph';
 import {
   getFilterOperation,
@@ -113,6 +114,11 @@ export type DataCubeExecutionResult = {
   executionTime: number;
 };
 
+export class DataCubeExecutionError extends Error {
+  executeInput?: PlainObject<V1_ExecuteInput> | undefined;
+  queryCode?: string | undefined;
+}
+
 /**
  * This is the base engine of DataCube, it provides capabilities that DataCube cannot itself
  * handle, such as query execution, compilation, etc.
@@ -279,7 +285,9 @@ export abstract class DataCubeEngine {
     return undefined;
   }
 
-  async disposeCache(source: CachedDataCubeSource) {}
+  async disposeCache(source: CachedDataCubeSource) {
+    // do nothing
+  }
 
   // ---------------------------------- APPLICATION ----------------------------------
 

package/src/stores/core/model/AdhocQueryDataCubeSource.ts

@@ -21,10 +21,11 @@ import {
 } from '@finos/legend-shared';
 import { DataCubeSource } from './DataCubeSource.js';
 import { createModelSchema, primitive, raw } from 'serializr';
+import type { V1_PureModelContext } from '@finos/legend-graph';
 
 export class AdhocQueryDataCubeSource extends DataCubeSource {
   runtime!: string;
-  model!: PlainObject;
+  model!: PlainObject<V1_PureModelContext>;
 }
 
 export const ADHOC_QUERY_DATA_CUBE_SOURCE_TYPE = 'adhocQuery';
@@ -32,7 +33,7 @@ export const ADHOC_QUERY_DATA_CUBE_SOURCE_TYPE = 'adhocQuery';
 export class RawAdhocQueryDataCubeSource {
   query!: string;
   runtime!: string;
-  model!: PlainObject;
+  model!: PlainObject<V1_PureModelContext>;
 
   static readonly serialization = new SerializationFactory(
     createModelSchema(RawAdhocQueryDataCubeSource, {

package/src/stores/core/model/CachedDataCubeSource.ts

@@ -16,11 +16,10 @@
 
 import type { V1_PureModelContextData } from '@finos/legend-graph';
 import { DataCubeSource } from './DataCubeSource.js';
-
-export const CACHED_DATA_CUBE_SOURCE_TYPE = 'cached';
+import type { PlainObject } from '@finos/legend-shared';
 
 export class CachedDataCubeSource extends DataCubeSource {
-  model!: V1_PureModelContextData;
+  model!: PlainObject<V1_PureModelContextData>;
   runtime!: string;
   db!: string;
   schema!: string;

package/src/stores/services/DataCubeAlertService.tsx

@@ -28,6 +28,8 @@ import { editor as monacoEditorAPI, Uri } from 'monaco-editor';
 import { DataCubeCodeCheckErrorAlert } from '../../components/core/DataCubeCodeCheckErrorAlert.js';
 import { uuid } from '@finos/legend-shared';
 import type { DataCubeLogService } from './DataCubeLogService.js';
+import type { DataCubeExecutionError } from '../core/DataCubeEngine.js';
+import { DataCubeExecutionErrorAlert } from '../../components/core/DataCubeExecutionErrorAlert.js';
 
 export enum AlertType {
   ERROR = 'ERROR',
@@ -166,4 +168,29 @@ export class DataCubeAlertService {
       this._layoutService.newWindow(window);
     }
   }
+
+  alertExecutionError(
+    error: DataCubeExecutionError,
+    options: ActionAlertOptions,
+  ) {
+    const { message, text, windowTitle, windowConfig } = options;
+    const window = new WindowState(
+      new LayoutConfiguration(windowTitle ?? 'Error', () => (
+        <DataCubeExecutionErrorAlert
+          error={error}
+          message={message}
+          text={text}
+          onClose={() => this._layoutService.closeWindow(window)}
+        />
+      )),
+    );
+    window.configuration.window = windowConfig ?? {
+      width: 600,
+      height: 250, // leave some space to show debug content
+      minWidth: 500,
+      minHeight: 200,
+      center: true,
+    };
+    this._layoutService.newWindow(window);
+  }
 }

package/src/stores/view/DataCubeViewState.ts

@@ -261,6 +261,7 @@ export class DataCubeViewState {
         });
 
         if (
+          this.grid.isCachingEnabled &&
           this.settingService.getBooleanValue(
             DataCubeSettingKey.GRID_CLIENT__SHOW_AUTO_ENABLE_CACHE_PERFORMANCE_WARNING,
           )

package/src/stores/view/editor/DataCubeEditorDimensionsPanelState.ts

@@ -0,0 +1,134 @@
+/**
+ * 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 { DataCubeConfiguration } from '../../core/model/DataCubeConfiguration.js';
+import { DataCubeColumnKind } from '../../core/DataCubeQueryEngine.js';
+import { type DataCubeSnapshot } from '../../core/DataCubeSnapshot.js';
+import { _findCol } from '../../core/model/DataCubeColumn.js';
+import {
+  DataCubeEditorColumnSelectorColumnState,
+  DataCubeEditorColumnSelectorState,
+} from './DataCubeEditorColumnSelectorState.js';
+import type { DataCubeQueryEditorPanelState } from './DataCubeEditorPanelState.js';
+import type { DataCubeEditorState } from './DataCubeEditorState.js';
+import { action, computed, makeObservable, observable } from 'mobx';
+
+export class DataCubeEditorVerticalPivotColumnSelectorState extends DataCubeEditorColumnSelectorState<DataCubeEditorColumnSelectorColumnState> {
+  override cloneColumn(
+    column: DataCubeEditorColumnSelectorColumnState,
+  ): DataCubeEditorColumnSelectorColumnState {
+    return new DataCubeEditorColumnSelectorColumnState(
+      column.name,
+      column.type,
+    );
+  }
+
+  override get availableColumns() {
+    return this._editor.columnProperties.columns
+      .filter(
+        (column) =>
+          column.kind === DataCubeColumnKind.DIMENSION &&
+          // exclude group-level extended columns
+          !_findCol(this._editor.groupExtendColumns, column.name) &&
+          // exclude pivot columns
+          !_findCol(
+            this._editor.horizontalPivots.selector.selectedColumns,
+            column.name,
+          ),
+      )
+      .map(
+        (col) =>
+          new DataCubeEditorColumnSelectorColumnState(col.name, col.type),
+      );
+  }
+
+  //
+}
+
+export class DataCubeEditorDimensionsPanelState
+  implements DataCubeQueryEditorPanelState
+{
+  readonly _editor!: DataCubeEditorState;
+
+  availableColumnsSearchText = '';
+  // readonly selector!: DataCubeEditorVerticalPivotColumnSelectorState;
+
+  constructor(editor: DataCubeEditorState) {
+    makeObservable(this, {
+      availableColumnsSearchText: observable,
+      setAvailableColumnsSearchText: action,
+
+      availableColumns: computed,
+    });
+
+    this._editor = editor;
+  }
+
+  get availableColumns() {
+    return this._editor.columnProperties.columns
+      .filter(
+        (column) =>
+          column.kind === DataCubeColumnKind.DIMENSION &&
+          // exclude group-level extended columns
+          !_findCol(this._editor.groupExtendColumns, column.name) &&
+          // exclude pivot columns
+          !_findCol(
+            this._editor.horizontalPivots.selector.selectedColumns,
+            column.name,
+          ),
+      )
+      .map(
+        (col) =>
+          new DataCubeEditorColumnSelectorColumnState(col.name, col.type),
+      );
+  }
+
+  setAvailableColumnsSearchText(val: string) {
+    this.availableColumnsSearchText = val;
+  }
+
+  // adaptPropagatedChanges(): void {
+  //   this.selector.setSelectedColumns(
+  //     this.selector.selectedColumns.filter((column) =>
+  //       _findCol(this.selector.availableColumns, column.name),
+  //     ),
+  //   );
+  // }
+
+  applySnaphot(
+    snapshot: DataCubeSnapshot,
+    configuration: DataCubeConfiguration,
+  ) {
+    // this.selector.setSelectedColumns(
+    //   (snapshot.data.groupBy?.columns ?? []).map(
+    //     (col) =>
+    //       new DataCubeEditorColumnSelectorColumnState(col.name, col.type),
+    //   ),
+    // );
+  }
+
+  buildSnapshot(newSnapshot: DataCubeSnapshot, baseSnapshot: DataCubeSnapshot) {
+    // newSnapshot.data.groupBy = this.selector.selectedColumns.length
+    //   ? {
+    //       columns: this.selector.selectedColumns.map(_toCol),
+    //     }
+    //   : undefined;
+    // newSnapshot.data.selectColumns = uniqBy(
+    //   [...newSnapshot.data.selectColumns, ...this.selector.selectedColumns],
+    //   (col) => col.name,
+    // ).map(_toCol);
+  }
+}

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

@@ -50,7 +50,10 @@ import type { DataCubeViewState } from '../DataCubeViewState.js';
 import { buildGridDataFetchExecutableQuery } from './DataCubeGridQueryBuilder.js';
 import { DataCubeSettingKey } from '../../../__lib__/DataCubeSetting.js';
 import { DEFAULT_ALERT_WINDOW_CONFIG } from '../../services/DataCubeLayoutService.js';
-import type { DataCubeExecutionResult } from '../../core/DataCubeEngine.js';
+import {
+  DataCubeExecutionError,
+  type DataCubeExecutionResult,
+} from '../../core/DataCubeEngine.js';
 import { _lambda } from '../../core/DataCubeQueryBuilderUtils.js';
 import { sum } from 'mathjs';
 
@@ -365,9 +368,16 @@ export class DataCubeGridClientServerSideDataSource
             );
           } catch (error) {
             assertErrorThrown(error);
-            this._view.alertService.alertError(error, {
-              message: `Query Validation Failure: Can't retrieve pivot results column metadata. ${error.message}`,
-            });
+            if (error instanceof DataCubeExecutionError) {
+              this._view.alertService.alertExecutionError(error, {
+                message: `Query Validation Failure: Can't retrieve pivot results column metadata.`,
+                text: `Error: ${error.message}`,
+              });
+            } else {
+              this._view.alertService.alertError(error, {
+                message: `Query Validation Failure: Can't retrieve pivot results column metadata. ${error.message}`,
+              });
+            }
             // fail early since we can't proceed without the cast columns validated
             params.fail();
             this._view.taskService.endTask(task);
@@ -418,9 +428,16 @@ export class DataCubeGridClientServerSideDataSource
       rowData = buildRowData(result.result.result, newSnapshot);
     } catch (error) {
       assertErrorThrown(error);
-      this._view.alertService.alertError(error, {
-        message: `Data Fetch Failure: ${error.message}`,
-      });
+      if (error instanceof DataCubeExecutionError) {
+        this._view.alertService.alertExecutionError(error, {
+          message: `Data Fetch Failure: Can't execute query.`,
+          text: `Error: ${error.message}`,
+        });
+      } else {
+        this._view.alertService.alertError(error, {
+          message: `Data Fetch Failure: ${error.message}`,
+        });
+      }
       this._view.taskService.endTask(task);
       params.fail();
       return;

package/tsconfig.json

@@ -82,6 +82,7 @@
     "./src/stores/view/editor/DataCubeEditorColumnPropertiesPanelState.ts",
     "./src/stores/view/editor/DataCubeEditorColumnSelectorState.ts",
     "./src/stores/view/editor/DataCubeEditorColumnsPanelState.ts",
+    "./src/stores/view/editor/DataCubeEditorDimensionsPanelState.ts",
     "./src/stores/view/editor/DataCubeEditorGeneralPropertiesPanelState.ts",
     "./src/stores/view/editor/DataCubeEditorHorizontalPivotsPanelState.ts",
     "./src/stores/view/editor/DataCubeEditorMutableConfiguration.ts",
@@ -105,6 +106,7 @@
     "./src/components/core/DataCubeAlert.tsx",
     "./src/components/core/DataCubeCodeCheckErrorAlert.tsx",
     "./src/components/core/DataCubeDocumentationPanel.tsx",
+    "./src/components/core/DataCubeExecutionErrorAlert.tsx",
     "./src/components/core/DataCubeFormUtils.tsx",
     "./src/components/core/DataCubeLayout.tsx",
     "./src/components/core/DataCubePureCodeEditorUtils.tsx",
@@ -113,6 +115,7 @@
     "./src/components/view/editor/DataCubeEditorColumnPropertiesPanel.tsx",
     "./src/components/view/editor/DataCubeEditorColumnSelector.tsx",
     "./src/components/view/editor/DataCubeEditorColumnsPanel.tsx",
+    "./src/components/view/editor/DataCubeEditorDimensionsPanel.tsx",
     "./src/components/view/editor/DataCubeEditorGeneralPropertiesPanel.tsx",
     "./src/components/view/editor/DataCubeEditorHorizontalPivotsPanel.tsx",
     "./src/components/view/editor/DataCubeEditorSortsPanel.tsx",
@@ -121,6 +124,7 @@
     "./src/components/view/filter/DataCubeFilterEditor.tsx",
     "./src/components/view/grid/DataCubeGrid.tsx",
     "./src/components/view/grid/DataCubeGridShared.tsx",
+    "./src/components/view/grid/DataCubeMultidimensionalGrid.tsx",
     "./src/stores/DataCubeState.tsx",
     "./src/stores/core/DataCubeEngine.tsx",
     "./src/stores/core/aggregation/DataCubeQueryAggregateOperation__Average.tsx",