@finos/legend-data-cube 0.0.2

package/src/stores/editor/DataCubeEditorColumnsPanelState.ts

@@ -0,0 +1,198 @@
+/**
+ * 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, override } from 'mobx';
+import type { DataCubeViewState } from '../DataCubeViewState.js';
+import {
+  _toCol,
+  type DataCubeQuerySnapshot,
+} from '../core/DataCubeQuerySnapshot.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';
+
+export class DataCubeEditorBasicColumnsSelectorState extends DataCubeEditorColumnsSelectorState<DataCubeEditorColumnsSelectorColumnState> {
+  showHiddenColumns = false;
+
+  constructor(
+    editor: DataCubeEditorState,
+    options?: {
+      onChange?:
+        | ((
+            select: DataCubeEditorColumnsSelectorState<DataCubeEditorColumnsSelectorColumnState>,
+          ) => void)
+        | undefined;
+    },
+  ) {
+    super(editor, options);
+
+    makeObservable(this, {
+      availableColumnsForDisplay: override,
+      selectedColumnsForDisplay: override,
+
+      showHiddenColumns: observable,
+      setShowHiddenColumns: action,
+    });
+  }
+
+  override cloneColumn(column: DataCubeEditorColumnsSelectorColumnState) {
+    return new DataCubeEditorColumnsSelectorColumnState(
+      column.name,
+      column.type,
+    );
+  }
+
+  override get availableColumns() {
+    return [
+      ...this.editor.sourceColumns,
+      ...this.editor.leafExtendColumns,
+      ...this.editor.groupExtendColumns,
+    ].map(
+      (col) => new DataCubeEditorColumnsSelectorColumnState(col.name, col.type),
+    );
+  }
+
+  override get availableColumnsForDisplay(): DataCubeEditorColumnsSelectorColumnState[] {
+    return super.availableColumnsForDisplay.filter(
+      (column) =>
+        this.showHiddenColumns ||
+        !this.editor.columnProperties.getColumnConfiguration(column.name)
+          .hideFromView,
+    );
+  }
+
+  override get selectedColumnsForDisplay(): DataCubeEditorColumnsSelectorColumnState[] {
+    return super.selectedColumnsForDisplay.filter(
+      (column) =>
+        this.showHiddenColumns ||
+        !this.editor.columnProperties.getColumnConfiguration(column.name)
+          .hideFromView,
+    );
+  }
+
+  setShowHiddenColumns(val: boolean): void {
+    this.showHiddenColumns = val;
+  }
+}
+
+/**
+ * This panel allows selection of columns (including extended columns) for the query.
+ *
+ * NOTE: this does not really represent the `select()` function in the query. Think about
+ * this column selection more intuitively from users' perspective, i.e. what columns they
+ * wish to see in the grid. Whereas the `select()` function actually impact the data fetching
+ * which should be computed based on more than just information coming from this panels, such
+ * as horizontal pivots and vertical pivots, since regardless of whether user choose to see
+ * those columns or not, they still need to be fetched.
+ */
+export class DataCubeEditorColumnsPanelState
+  implements DataCubeQueryEditorPanelState
+{
+  readonly view!: DataCubeViewState;
+  readonly editor!: DataCubeEditorState;
+  readonly selector!: DataCubeEditorBasicColumnsSelectorState;
+
+  constructor(editor: DataCubeEditorState) {
+    makeObservable(this, {
+      applySnaphot: action,
+    });
+
+    this.editor = editor;
+    this.view = editor.view;
+    this.selector = new DataCubeEditorBasicColumnsSelectorState(editor, {
+      onChange: (selector) => {
+        const selectedColumnConfigurations = selector.selectedColumns.map(
+          (col) =>
+            this.editor.columnProperties.getColumnConfiguration(col.name),
+        );
+        const unselectedColumnConfigurations =
+          this.editor.columnProperties.columns.filter(
+            (col) => !selectedColumnConfigurations.includes(col),
+          );
+
+        // update selection config in column configurations and apply the
+        // order of selected columns in the column configurations list (unselected
+        // columns are kept in the same order and placed after all selected ones)
+        selectedColumnConfigurations.forEach((col) => col.setIsSelected(true));
+        unselectedColumnConfigurations.forEach((col) =>
+          col.setIsSelected(false),
+        );
+        this.editor.columnProperties.setColumns([
+          ...selectedColumnConfigurations,
+          ...unselectedColumnConfigurations,
+        ]);
+      },
+    });
+  }
+
+  /**
+   * NOTE: Ideally, this should be called on every changes made to the column selection, but to
+   * give user some room for error, i.e. when user accidentally select/deselect columns, we would
+   * not propagate this change until user either leaves this panel or explicitly applies changes
+   * (i.e. publishes a new snapshot)
+   */
+  propagateChanges(): void {
+    this.editor.sorts.adaptPropagatedChanges();
+  }
+
+  applySnaphot(
+    snapshot: DataCubeQuerySnapshot,
+    configuration: DataCubeConfiguration,
+  ) {
+    this.selector.setSelectedColumns(
+      this.editor.columnProperties.columns
+        // extract from the configuration since it specifies the order of columns
+        // there taking into account group-level extended columns
+        .filter((col) => col.isSelected)
+        .map((col) => {
+          const column = this.selector.getColumn(col.name);
+          return new DataCubeEditorColumnsSelectorColumnState(
+            column.name,
+            column.type,
+          );
+        }),
+    );
+  }
+
+  buildSnapshot(
+    newSnapshot: DataCubeQuerySnapshot,
+    baseSnapshot: DataCubeQuerySnapshot,
+  ) {
+    this.propagateChanges();
+    // NOTE: these columns make up just part of the set of columns we want to fetch with `select()`.
+    // Subsequently, we need to include columns used for horizontal pivots and vertical pivots.
+    //
+    // Note that this is a fairly simple way to determine the set of columns to fetch, but we have a
+    // compile check to ensure the columns needed by parts we don't account for well such as group-level
+    // extended columns must be properly included.
+    //
+    // Maybe, we can improve this later by having an algorithm to determine the set of columns needed
+    // by each extended column.
+    newSnapshot.data.selectColumns = this.selector.selectedColumns
+      // filter out group-level extended columns since these columns are technically not selectable
+      .filter(
+        (col) =>
+          !this.editor.groupExtendColumns.find(
+            (column) => column.name === col.name,
+          ),
+      )
+      .map(_toCol);
+  }
+}

package/src/stores/editor/DataCubeEditorColumnsSelectorState.ts

@@ -0,0 +1,115 @@
+/**
+ * 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 { makeObservable, observable, action, computed } from 'mobx';
+import type { DataCubeViewState } from '../DataCubeViewState.js';
+import type { DataCubeEditorState } from './DataCubeEditorState.js';
+import { guaranteeNonNullable } from '@finos/legend-shared';
+import { _sortByColName } from '../core/DataCubeQuerySnapshot.js';
+
+export class DataCubeEditorColumnsSelectorColumnState {
+  readonly name: string;
+  readonly type: string;
+
+  constructor(name: string, type: string) {
+    this.name = name;
+    this.type = type;
+  }
+}
+
+export abstract class DataCubeEditorColumnsSelectorState<
+  T extends DataCubeEditorColumnsSelectorColumnState,
+> {
+  readonly view!: DataCubeViewState;
+  readonly editor!: DataCubeEditorState;
+
+  selectedColumns: T[] = [];
+
+  availableColumnsSearchText = '';
+  selectedColumnsSearchText = '';
+
+  readonly onChange?:
+    | ((selector: DataCubeEditorColumnsSelectorState<T>) => void)
+    | undefined;
+
+  constructor(
+    editor: DataCubeEditorState,
+    options?: {
+      onChange?:
+        | ((select: DataCubeEditorColumnsSelectorState<T>) => void)
+        | undefined;
+    },
+  ) {
+    makeObservable(this, {
+      availableColumns: computed,
+      availableColumnsForDisplay: computed,
+      selectedColumnsForDisplay: computed,
+
+      selectedColumns: observable,
+      setSelectedColumns: action,
+
+      availableColumnsSearchText: observable,
+      setAvailableColumnsSearchText: action,
+
+      selectedColumnsSearchText: observable,
+      setSelectedColumnsSearchText: action,
+    });
+
+    this.editor = editor;
+    this.view = editor.view;
+    this.onChange = options?.onChange;
+  }
+
+  abstract get availableColumns(): T[];
+
+  get availableColumnsForDisplay(): T[] {
+    return this.availableColumns
+      .filter(
+        (column) =>
+          !this.selectedColumns.find((col) => column.name === col.name),
+      )
+      .sort(_sortByColName);
+  }
+
+  get selectedColumnsForDisplay(): T[] {
+    return this.selectedColumns;
+  }
+
+  setSelectedColumns(val: T[]) {
+    // NOTE: since we have a list of columns available which we treat as
+    // "templates" to select from, we need to clone these columns in order
+    // to avoid modifying the original available columns
+    this.selectedColumns = val.map((col) => this.cloneColumn(col));
+    this.onChange?.(this);
+  }
+
+  setAvailableColumnsSearchText(val: string) {
+    this.availableColumnsSearchText = val;
+  }
+
+  setSelectedColumnsSearchText(val: string) {
+    this.selectedColumnsSearchText = val;
+  }
+
+  getColumn(colName: string): T {
+    return guaranteeNonNullable(
+      this.availableColumns.find((col) => col.name === colName),
+      `Can't find column '${colName}'`,
+    );
+  }
+
+  protected abstract cloneColumn(column: T): T;
+}

package/src/stores/editor/DataCubeEditorGeneralPropertiesPanelState.ts

@@ -0,0 +1,87 @@
+/**
+ * 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 type { DataCubeQueryEditorPanelState } from './DataCubeEditorPanelState.js';
+import type { DataCubeEditorState } from './DataCubeEditorState.js';
+import { DataCubeEditorMutableConfiguration } from './DataCubeEditorMutableConfiguration.js';
+import type { DataCubeConfiguration } from '../core/DataCubeConfiguration.js';
+
+export class DataCubeEditorGeneralPropertiesPanelState
+  implements DataCubeQueryEditorPanelState
+{
+  readonly view!: DataCubeViewState;
+  readonly editor!: DataCubeEditorState;
+
+  name = '';
+  limit = -1;
+  configuration = new DataCubeEditorMutableConfiguration();
+
+  constructor(editor: DataCubeEditorState) {
+    makeObservable(this, {
+      name: observable,
+      setName: action,
+
+      limit: observable,
+      setLimit: action,
+
+      configuration: observable,
+      setConfiguration: action,
+    });
+
+    this.editor = editor;
+    this.view = editor.view;
+  }
+
+  setName(val: string) {
+    this.name = val;
+  }
+
+  setLimit(val: number) {
+    this.limit = val;
+  }
+
+  setConfiguration(val: DataCubeEditorMutableConfiguration) {
+    this.configuration = val;
+  }
+
+  applySnaphot(
+    snapshot: DataCubeQuerySnapshot,
+    configuration: DataCubeConfiguration,
+  ) {
+    this.setName(snapshot.data.name);
+    this.setLimit(
+      snapshot.data.limit !== undefined && snapshot.data.limit >= 0
+        ? snapshot.data.limit
+        : -1,
+    );
+    this.setConfiguration(
+      DataCubeEditorMutableConfiguration.create(snapshot.data.configuration),
+    );
+  }
+
+  buildSnapshot(
+    newSnapshot: DataCubeQuerySnapshot,
+    baseSnapshot: DataCubeQuerySnapshot,
+  ) {
+    const data = newSnapshot.data;
+    data.name = this.name;
+    data.limit = this.limit < 0 ? undefined : this.limit;
+    data.configuration = this.configuration.serialize();
+  }
+}

package/src/stores/editor/DataCubeEditorHorizontalPivotsPanelState.ts

@@ -0,0 +1,132 @@
+/**
+ * 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, computed, makeObservable, observable } from 'mobx';
+import type { DataCubeViewState } from '../DataCubeViewState.js';
+import type { DataCubeConfiguration } from '../core/DataCubeConfiguration.js';
+import {
+  DataCubeColumnKind,
+  isPivotResultColumnName,
+} from '../core/DataCubeQueryEngine.js';
+import {
+  _toCol,
+  type DataCubeQuerySnapshot,
+  type DataCubeQuerySnapshotColumn,
+} from '../core/DataCubeQuerySnapshot.js';
+import {
+  DataCubeEditorColumnsSelectorColumnState,
+  DataCubeEditorColumnsSelectorState,
+} from './DataCubeEditorColumnsSelectorState.js';
+import type { DataCubeQueryEditorPanelState } from './DataCubeEditorPanelState.js';
+import type { DataCubeEditorState } from './DataCubeEditorState.js';
+import { uniqBy } from '@finos/legend-shared';
+
+export class DataCubeEditorHorizontalPivotColumnsSelectorState extends DataCubeEditorColumnsSelectorState<DataCubeEditorColumnsSelectorColumnState> {
+  override cloneColumn(
+    column: DataCubeEditorColumnsSelectorColumnState,
+  ): DataCubeEditorColumnsSelectorColumnState {
+    return new DataCubeEditorColumnsSelectorColumnState(
+      column.name,
+      column.type,
+    );
+  }
+
+  override get availableColumns() {
+    return this.editor.columnProperties.columns
+      .filter(
+        (col) =>
+          col.kind === DataCubeColumnKind.DIMENSION &&
+          // exclude group-level extended columns
+          !this.editor.groupExtendColumns.find(
+            (column) => column.name === col.name,
+          ),
+      )
+      .map(
+        (col) =>
+          new DataCubeEditorColumnsSelectorColumnState(col.name, col.type),
+      );
+  }
+}
+
+export class DataCubeEditorHorizontalPivotsPanelState
+  implements DataCubeQueryEditorPanelState
+{
+  readonly view!: DataCubeViewState;
+  readonly editor!: DataCubeEditorState;
+  readonly selector!: DataCubeEditorHorizontalPivotColumnsSelectorState;
+
+  castColumns: DataCubeQuerySnapshotColumn[] = [];
+
+  constructor(editor: DataCubeEditorState) {
+    makeObservable(this, {
+      castColumns: observable.ref,
+      pivotResultColumns: computed,
+      setCastColumns: action,
+
+      applySnaphot: action,
+    });
+
+    this.editor = editor;
+    this.view = editor.view;
+    this.selector = new DataCubeEditorHorizontalPivotColumnsSelectorState(
+      editor,
+    );
+  }
+
+  get pivotResultColumns(): DataCubeQuerySnapshotColumn[] {
+    return this.castColumns
+      .filter((col) => isPivotResultColumnName(col.name))
+      .map(_toCol);
+  }
+
+  setCastColumns(value: DataCubeQuerySnapshotColumn[]) {
+    this.castColumns = value;
+  }
+
+  propagateChanges() {
+    this.editor.verticalPivots.adaptPropagatedChanges();
+    this.editor.sorts.adaptPropagatedChanges();
+  }
+
+  applySnaphot(
+    snapshot: DataCubeQuerySnapshot,
+    configuration: DataCubeConfiguration,
+  ) {
+    this.selector.setSelectedColumns(
+      (snapshot.data.pivot?.columns ?? []).map(
+        (col) =>
+          new DataCubeEditorColumnsSelectorColumnState(col.name, col.type),
+      ),
+    );
+    this.setCastColumns(snapshot.data.pivot?.castColumns ?? []);
+  }
+
+  buildSnapshot(
+    newSnapshot: DataCubeQuerySnapshot,
+    baseSnapshot: DataCubeQuerySnapshot,
+  ) {
+    newSnapshot.data.pivot = this.selector.selectedColumns.length
+      ? {
+          columns: this.selector.selectedColumns.map(_toCol),
+          castColumns: this.castColumns.map(_toCol),
+        }
+      : undefined;
+    newSnapshot.data.selectColumns = uniqBy(
+      [...newSnapshot.data.selectColumns, ...this.selector.selectedColumns],
+      (col) => col.name,
+    ).map(_toCol);
+  }
+}