@finos/legend-data-cube 0.0.2

package/src/stores/editor/DataCubeEditorSortsPanelState.ts

@@ -0,0 +1,147 @@
+/**
+ * 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 { DataCubeViewState } from '../DataCubeViewState.js';
+import { type DataCubeQuerySnapshot } from '../core/DataCubeQuerySnapshot.js';
+import {
+  DataCubeColumnKind,
+  DataCubeQuerySortOperator,
+} from '../core/DataCubeQueryEngine.js';
+import type { DataCubeQueryEditorPanelState } from './DataCubeEditorPanelState.js';
+import {
+  DataCubeEditorColumnsSelectorColumnState,
+  DataCubeEditorColumnsSelectorState,
+} from './DataCubeEditorColumnsSelectorState.js';
+import type { DataCubeEditorState } from './DataCubeEditorState.js';
+import type { DataCubeConfiguration } from '../core/DataCubeConfiguration.js';
+import { uniqBy } from '@finos/legend-shared';
+
+export class DataCubeEditorSortColumnState extends DataCubeEditorColumnsSelectorColumnState {
+  operation: string;
+
+  constructor(name: string, type: string, direction: string) {
+    super(name, type);
+
+    makeObservable(this, {
+      operation: observable,
+      setOperation: action,
+    });
+
+    this.operation = direction;
+  }
+
+  setOperation(val: DataCubeQuerySortOperator) {
+    this.operation = val;
+  }
+}
+
+export class DataCubeEditorSortColumnsSelectorState extends DataCubeEditorColumnsSelectorState<DataCubeEditorSortColumnState> {
+  override cloneColumn(column: DataCubeEditorSortColumnState) {
+    return new DataCubeEditorSortColumnState(
+      column.name,
+      column.type,
+      column.operation,
+    );
+  }
+
+  override get availableColumns() {
+    return uniqBy(
+      [
+        // if pivot is active, take the pivot result columns and include
+        // selected dimension columns which are not part of pivot columns
+        ...(this.editor.horizontalPivots.selector.selectedColumns.length
+          ? [
+              ...this.editor.horizontalPivots.pivotResultColumns,
+              ...[
+                ...this.editor.columns.selector.selectedColumns,
+                ...this.editor.verticalPivots.selector.selectedColumns,
+              ].filter(
+                (column) =>
+                  this.editor.columnProperties.getColumnConfiguration(
+                    column.name,
+                  ).kind === DataCubeColumnKind.DIMENSION &&
+                  !this.editor.horizontalPivots.selector.selectedColumns.find(
+                    (col) => col.name === column.name,
+                  ),
+              ),
+            ]
+          : [
+              ...this.editor.columns.selector.selectedColumns,
+              ...this.editor.verticalPivots.selector.selectedColumns,
+            ]),
+        ...this.editor.groupExtendColumns,
+      ],
+      (col) => col.name,
+    ).map(
+      (col) =>
+        new DataCubeEditorSortColumnState(
+          col.name,
+          col.type,
+          DataCubeQuerySortOperator.ASCENDING,
+        ),
+    );
+  }
+}
+
+export class DataCubeEditorSortsPanelState
+  implements DataCubeQueryEditorPanelState
+{
+  readonly view!: DataCubeViewState;
+  readonly editor!: DataCubeEditorState;
+  readonly selector!: DataCubeEditorColumnsSelectorState<DataCubeEditorSortColumnState>;
+
+  constructor(editor: DataCubeEditorState) {
+    this.editor = editor;
+    this.view = editor.view;
+    this.selector = new DataCubeEditorSortColumnsSelectorState(editor);
+  }
+
+  adaptPropagatedChanges(): void {
+    this.selector.setSelectedColumns(
+      this.selector.selectedColumns.filter((column) =>
+        this.selector.availableColumns.find((col) => col.name === column.name),
+      ),
+    );
+  }
+
+  applySnaphot(
+    snapshot: DataCubeQuerySnapshot,
+    configuration: DataCubeConfiguration,
+  ) {
+    this.selector.setSelectedColumns(
+      snapshot.data.sortColumns.map((col) => {
+        const column = this.selector.getColumn(col.name);
+        return new DataCubeEditorSortColumnState(
+          column.name,
+          column.type,
+          col.operation,
+        );
+      }),
+    );
+  }
+
+  buildSnapshot(
+    newSnapshot: DataCubeQuerySnapshot,
+    baseSnapshot: DataCubeQuerySnapshot,
+  ) {
+    newSnapshot.data.sortColumns = this.selector.selectedColumns.map((col) => ({
+      name: col.name,
+      type: col.type,
+      operation: col.operation,
+    }));
+  }
+}

package/src/stores/editor/DataCubeEditorState.tsx

@@ -0,0 +1,206 @@
+/**
+ * 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 { DataCubeViewState } from '../DataCubeViewState.js';
+import { DataCubeEditorSortsPanelState } from './DataCubeEditorSortsPanelState.js';
+import { DataCubeQuerySnapshotController } from '../core/DataCubeQuerySnapshotManager.js';
+import {
+  _toCol,
+  type DataCubeQuerySnapshot,
+  type DataCubeQuerySnapshotColumn,
+  type DataCubeQuerySnapshotExtendedColumn,
+} from '../core/DataCubeQuerySnapshot.js';
+import {
+  ActionState,
+  assertErrorThrown,
+  guaranteeNonNullable,
+} 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 { 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 { DataCubeEditorHorizontalPivotsPanelState } from './DataCubeEditorHorizontalPivotsPanelState.js';
+
+export enum DataCubeEditorTab {
+  GENERAL_PROPERTIES = 'General Properties',
+  COLUMN_PROPERTIES = 'Column Properties',
+  COLUMNS = 'Columns',
+  VERTICAL_PIVOTS = 'Vertical Pivots',
+  HORIZONTAL_PIVOTS = 'Horizontal Pivots',
+  SORTS = 'Sorts',
+}
+
+/**
+ * This query editor state backs the main form editor of data cube. It supports
+ * batching changes before application, i.e. allowing user to make multiple edits before
+ * applying and propgating them.
+ *
+ * NOTE: It allows almost FULL 1-1 control over the data cube query state.
+ * It could also host other form editor states like filter editors, but due to ergonomic
+ * reasons, those have been separated out into their own respective query editor states.
+ */
+export class DataCubeEditorState extends DataCubeQuerySnapshotController {
+  readonly display: DisplayState;
+  readonly finalizationState = ActionState.create();
+
+  readonly generalProperties: DataCubeEditorGeneralPropertiesPanelState;
+  readonly columnProperties: DataCubeEditorColumnPropertiesPanelState;
+
+  readonly columns: DataCubeEditorColumnsPanelState;
+  readonly horizontalPivots: DataCubeEditorHorizontalPivotsPanelState;
+  readonly verticalPivots: DataCubeEditorVerticalPivotsPanelState;
+  readonly sorts: DataCubeEditorSortsPanelState;
+
+  currentTab = DataCubeEditorTab.GENERAL_PROPERTIES;
+
+  sourceColumns: DataCubeQuerySnapshotColumn[] = [];
+  leafExtendColumns: DataCubeQuerySnapshotExtendedColumn[] = [];
+  groupExtendColumns: DataCubeQuerySnapshotExtendedColumn[] = [];
+
+  constructor(view: DataCubeViewState) {
+    super(view);
+
+    makeObservable(this, {
+      currentTab: observable,
+      setCurrentTab: action,
+
+      sourceColumns: observable.ref,
+      leafExtendColumns: observable.ref,
+      groupExtendColumns: observable.ref,
+
+      applySnapshot: action,
+      applyChanges: action,
+    });
+
+    this.display = this.view.application.layout.newDisplay('Properties', () => (
+      <DataCubeEditor view={this.view} />
+    ));
+    this.generalProperties = new DataCubeEditorGeneralPropertiesPanelState(
+      this,
+    );
+    this.columnProperties = new DataCubeEditorColumnPropertiesPanelState(this);
+    this.columns = new DataCubeEditorColumnsPanelState(this);
+    this.horizontalPivots = new DataCubeEditorHorizontalPivotsPanelState(this);
+    this.verticalPivots = new DataCubeEditorVerticalPivotsPanelState(this);
+    this.sorts = new DataCubeEditorSortsPanelState(this);
+  }
+
+  setCurrentTab(val: DataCubeEditorTab) {
+    this.currentTab = val;
+  }
+
+  override async applySnapshot(
+    snapshot: DataCubeQuerySnapshot,
+    previousSnapshot: DataCubeQuerySnapshot | undefined,
+  ) {
+    this.sourceColumns = snapshot.data.sourceColumns;
+    this.leafExtendColumns = snapshot.data.leafExtendedColumns;
+    this.groupExtendColumns = snapshot.data.groupExtendedColumns;
+
+    const configuration = DataCubeConfiguration.serialization.fromJson(
+      snapshot.data.configuration,
+    );
+    this.generalProperties.applySnaphot(snapshot, configuration);
+    this.columnProperties.applySnaphot(snapshot, configuration);
+
+    this.columns.applySnaphot(snapshot, configuration);
+    this.horizontalPivots.applySnaphot(snapshot, configuration);
+    this.verticalPivots.applySnaphot(snapshot, configuration);
+    this.sorts.applySnaphot(snapshot, configuration);
+  }
+
+  async applyChanges(options?: { closeAfterApply?: boolean | undefined }) {
+    const task = this.view.newTask('Validate query');
+    this.finalizationState.inProgress();
+
+    const baseSnapshot = guaranteeNonNullable(this.getLatestSnapshot());
+    const newSnapshot = baseSnapshot.clone();
+
+    // grid configuration must be processed before processing columns' configuration
+    // to properly generate the container configuration
+    this.generalProperties.buildSnapshot(newSnapshot, baseSnapshot);
+    this.columnProperties.buildSnapshot(newSnapshot, baseSnapshot);
+
+    // NOTE: column selection must be processed first since the snapshot
+    // processing of other parts of the query can be affected by column selection.
+    this.columns.buildSnapshot(newSnapshot, baseSnapshot);
+    this.horizontalPivots.buildSnapshot(newSnapshot, baseSnapshot);
+    this.verticalPivots.buildSnapshot(newSnapshot, baseSnapshot);
+    this.sorts.buildSnapshot(newSnapshot, baseSnapshot);
+
+    // finalize
+    newSnapshot.finalize();
+    if (newSnapshot.hashCode !== baseSnapshot.hashCode) {
+      // 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.
+      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,
+              ),
+            ],
+          ),
+        );
+      } catch (error) {
+        assertErrorThrown(error);
+        this.view.application.alertError(error, {
+          message: `Query Validation Failure: ${error.message}`,
+        });
+        this.view.endTask(task);
+        return;
+      } finally {
+        this.finalizationState.complete();
+      }
+
+      this.publishSnapshot(newSnapshot);
+    } else {
+      this.finalizationState.complete();
+    }
+
+    if (options?.closeAfterApply) {
+      this.display.close();
+    }
+    this.view.endTask(task);
+  }
+}

package/src/stores/editor/DataCubeEditorVerticalPivotsPanelState.ts

@@ -0,0 +1,110 @@
+/**
+ * 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 { 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 {
+  _toCol,
+  type DataCubeQuerySnapshot,
+} from '../core/DataCubeQuerySnapshot.js';
+import {
+  DataCubeEditorColumnsSelectorColumnState,
+  DataCubeEditorColumnsSelectorState,
+} from './DataCubeEditorColumnsSelectorState.js';
+import type { DataCubeQueryEditorPanelState } from './DataCubeEditorPanelState.js';
+import type { DataCubeEditorState } from './DataCubeEditorState.js';
+
+export class DataCubeEditorVerticalPivotColumnsSelectorState extends DataCubeEditorColumnsSelectorState<DataCubeEditorColumnsSelectorColumnState> {
+  override cloneColumn(
+    column: DataCubeEditorColumnsSelectorColumnState,
+  ): DataCubeEditorColumnsSelectorColumnState {
+    return new DataCubeEditorColumnsSelectorColumnState(
+      column.name,
+      column.type,
+    );
+  }
+
+  override get availableColumns() {
+    return this.editor.columnProperties.columns
+      .filter(
+        (column) =>
+          column.kind === DataCubeColumnKind.DIMENSION &&
+          // exclude group-level extended columns
+          !this.editor.groupExtendColumns.find(
+            (col) => col.name === column.name,
+          ) &&
+          // exclude pivot columns
+          !this.editor.horizontalPivots.selector.selectedColumns.find(
+            (col) => col.name === column.name,
+          ),
+      )
+      .map(
+        (col) =>
+          new DataCubeEditorColumnsSelectorColumnState(col.name, col.type),
+      );
+  }
+}
+
+export class DataCubeEditorVerticalPivotsPanelState
+  implements DataCubeQueryEditorPanelState
+{
+  readonly view!: DataCubeViewState;
+  readonly editor!: DataCubeEditorState;
+  readonly selector!: DataCubeEditorVerticalPivotColumnsSelectorState;
+
+  constructor(editor: DataCubeEditorState) {
+    this.editor = editor;
+    this.view = editor.view;
+    this.selector = new DataCubeEditorVerticalPivotColumnsSelectorState(editor);
+  }
+
+  adaptPropagatedChanges(): void {
+    this.selector.setSelectedColumns(
+      this.selector.selectedColumns.filter((column) =>
+        this.selector.availableColumns.find((col) => col.name === column.name),
+      ),
+    );
+  }
+
+  applySnaphot(
+    snapshot: DataCubeQuerySnapshot,
+    configuration: DataCubeConfiguration,
+  ) {
+    this.selector.setSelectedColumns(
+      (snapshot.data.groupBy?.columns ?? []).map(
+        (col) =>
+          new DataCubeEditorColumnsSelectorColumnState(col.name, col.type),
+      ),
+    );
+  }
+
+  buildSnapshot(
+    newSnapshot: DataCubeQuerySnapshot,
+    baseSnapshot: DataCubeQuerySnapshot,
+  ) {
+    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/engine/DataCubeApplicationEngine.tsx

@@ -0,0 +1,120 @@
+/**
+ * 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 { LogEvent, DocumentationEntry } from '@finos/legend-shared';
+import { action, makeObservable, observable } from 'mobx';
+import {
+  Alert,
+  AlertType,
+  type ActionAlert,
+  type ActionAlertAction,
+} from '../../components/application/DataCubeAlert.js';
+import {
+  DEFAULT_SMALL_ALERT_WINDOW_CONFIG,
+  LayoutConfiguration,
+  LayoutManagerState,
+  WindowState,
+  type WindowConfiguration,
+} from './DataCubeLayoutManagerState.js';
+
+export abstract class DataCubeApplicationEngine {
+  readonly layout: LayoutManagerState;
+
+  currentDocumentationEntry: DocumentationEntry | undefined;
+  currentActionAlert: ActionAlert | undefined;
+
+  constructor() {
+    makeObservable(this, {
+      currentDocumentationEntry: observable,
+      openDocumentationEntry: action,
+
+      currentActionAlert: observable,
+      alertAction: action,
+    });
+
+    this.layout = new LayoutManagerState();
+  }
+
+  abstract get documentationUrl(): string | undefined;
+  abstract getDocumentationEntry(key: string): DocumentationEntry | undefined;
+  abstract openDocumentationEntry(entry: DocumentationEntry): void;
+  abstract shouldDisplayDocumentationEntry(entry: DocumentationEntry): boolean;
+
+  abstract openLink(url: string): void;
+  abstract setWindowTitle(title: string): void;
+
+  abstract logDebug(message: string, ...data: unknown[]): void;
+  abstract debugProcess(processName: string, ...data: unknown[]): void;
+  abstract logInfo(event: LogEvent, ...data: unknown[]): void;
+  abstract logWarning(event: LogEvent, ...data: unknown[]): void;
+  abstract logError(event: LogEvent, ...data: unknown[]): void;
+  abstract logUnhandledError(error: Error): void;
+  abstract logIllegalStateError(message: string, error?: Error): void;
+
+  abstract alertAction(alertInfo: ActionAlert | undefined): void;
+  abstract alertUnhandledError(error: Error): void;
+
+  alertError(
+    error: Error,
+    options: {
+      message: string;
+      text?: string | undefined;
+      actions?: ActionAlertAction[] | undefined;
+      windowTitle?: string | undefined;
+      windowConfig?: WindowConfiguration | undefined;
+    },
+  ) {
+    const { message, text, actions, windowTitle, windowConfig } = options;
+    const window = new WindowState(
+      new LayoutConfiguration(windowTitle ?? 'Error', () => (
+        <Alert
+          type={AlertType.ERROR}
+          message={message}
+          text={text}
+          actions={actions}
+        />
+      )),
+    );
+    window.configuration.window =
+      windowConfig ?? DEFAULT_SMALL_ALERT_WINDOW_CONFIG;
+    this.layout.newWindow(window);
+  }
+
+  alert(options: {
+    message: string;
+    type: AlertType;
+    text?: string | undefined;
+    actions?: ActionAlertAction[] | undefined;
+    windowTitle?: string | undefined;
+    windowConfig?: WindowConfiguration | undefined;
+  }) {
+    const { message, type, text, actions, windowTitle, windowConfig } = options;
+    const window = new WindowState(
+      new LayoutConfiguration(windowTitle ?? '', () => (
+        <Alert
+          type={type}
+          message={message}
+          text={text}
+          actions={actions}
+          onClose={() => this.layout.closeWindow(window)}
+        />
+      )),
+    );
+    window.configuration.window =
+      windowConfig ?? DEFAULT_SMALL_ALERT_WINDOW_CONFIG;
+    this.layout.newWindow(window);
+  }
+}