@finos/legend-data-cube 0.0.2

package/src/stores/DataCubeState.tsx

@@ -0,0 +1,100 @@
+/**
+ * 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 DataCubeEngine } from './engine/DataCubeEngine.js';
+import { DataCubeViewState } from './DataCubeViewState.js';
+import type { DisplayState } from './engine/DataCubeLayoutManagerState.js';
+import { DocumentationPanel } from '../components/application/DataCubeDocumentationPanel.js';
+import { DataCubeSettingsPanel } from '../components/application/DataCubeSettingsPanel.js';
+import { ActionState, assertErrorThrown } from '@finos/legend-shared';
+import { AlertType } from '../components/application/DataCubeAlert.js';
+import { type DataCubeApplicationEngine } from './engine/DataCubeApplicationEngine.js';
+
+export class DataCubeState {
+  readonly application: DataCubeApplicationEngine;
+  readonly engine: DataCubeEngine;
+
+  readonly initState = ActionState.create();
+
+  readonly settingsDisplay: DisplayState;
+  readonly documentationDisplay: DisplayState;
+
+  // NOTE: when we support multiview, there can be multiple view states to support
+  // the first one in that list will be taken as the main view state
+  readonly view: DataCubeViewState;
+
+  constructor(application: DataCubeApplicationEngine, engine: DataCubeEngine) {
+    this.application = application;
+    this.engine = engine;
+    this.engine.viewTaskRunner = (task) => this.runTaskForAllViews(task);
+    this.view = new DataCubeViewState(this);
+
+    this.settingsDisplay = this.application.layout.newDisplay(
+      'Settings',
+      () => <DataCubeSettingsPanel />,
+      {
+        x: -50,
+        y: 50,
+        width: 600,
+        height: 400,
+        minWidth: 300,
+        minHeight: 200,
+        center: false,
+      },
+    );
+    this.documentationDisplay = this.application.layout.newDisplay(
+      'Documentation',
+      () => <DocumentationPanel />,
+      {
+        x: -50,
+        y: -50,
+        width: 400,
+        height: 400,
+        minWidth: 300,
+        minHeight: 200,
+        center: false,
+      },
+    );
+  }
+
+  private runTaskForAllViews(task: (view: DataCubeViewState) => void): void {
+    // TODO: When we support multi-view (i.e. multiple instances of DataCubes) we would need
+    // to traverse through and update the configurations of all of their grid clients
+    task(this.view);
+  }
+
+  async initialize() {
+    if (!this.initState.isInInitialState) {
+      this.application.logDebug('REPL store is re-initialized');
+      return;
+    }
+    this.initState.inProgress();
+
+    try {
+      await this.engine.initialize();
+      this.initState.pass();
+    } catch (error: unknown) {
+      assertErrorThrown(error);
+      this.application.alertAction({
+        message: `Initialization Failure: ${error.message}`,
+        prompt: `Resolve the issue and reload the application.`,
+        type: AlertType.ERROR,
+        actions: [],
+      });
+      this.initState.fail();
+    }
+  }
+}

package/src/stores/DataCubeViewState.ts

@@ -0,0 +1,129 @@
+/**
+ * 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 { DataCubeGridState } from './grid/DataCubeGridState.js';
+import { DataCubeEditorState } from './editor/DataCubeEditorState.js';
+import { assertErrorThrown, uuid } from '@finos/legend-shared';
+import { DataCubeQuerySnapshotManager } from './core/DataCubeQuerySnapshotManager.js';
+import { DataCubeInfoState } from './core/DataCubeInfoState.js';
+import { validateAndBuildQuerySnapshot } from './core/DataCubeQuerySnapshotBuilder.js';
+import { action, makeObservable, observable } from 'mobx';
+import { DataCubeFilterEditorState } from './filter/DataCubeFilterEditorState.js';
+import { DataCubeExtendManagerState } from './extend/DataCubeExtendManagerState.js';
+import type { DataCubeState } from './DataCubeState.js';
+import type { DataCubeEngine } from './engine/DataCubeEngine.js';
+import { type DataCubeApplicationEngine } from './engine/DataCubeApplicationEngine.js';
+import { AlertType } from '../components/application/DataCubeAlert.js';
+
+class DataCubeTask {
+  uuid = uuid();
+  name: string;
+  startTime = Date.now();
+  endTime?: number | undefined;
+
+  constructor(name: string) {
+    this.name = name;
+  }
+
+  end() {
+    this.endTime = Date.now();
+  }
+}
+
+export class DataCubeViewState {
+  readonly dataCube: DataCubeState;
+  readonly application: DataCubeApplicationEngine;
+  readonly engine: DataCubeEngine;
+
+  readonly snapshotManager: DataCubeQuerySnapshotManager;
+
+  readonly info: DataCubeInfoState;
+  readonly editor: DataCubeEditorState;
+  readonly grid: DataCubeGridState;
+  readonly filter: DataCubeFilterEditorState;
+  readonly extend: DataCubeExtendManagerState;
+
+  readonly runningTasks = new Map<string, DataCubeTask>();
+
+  constructor(dataCube: DataCubeState) {
+    makeObservable(this, {
+      runningTasks: observable,
+      newTask: action,
+      endTask: action,
+    });
+
+    this.dataCube = dataCube;
+    this.application = dataCube.application;
+    this.engine = dataCube.engine;
+
+    // NOTE: snapshot manager must be instantiated before subscribers
+    this.snapshotManager = new DataCubeQuerySnapshotManager(this);
+
+    this.info = new DataCubeInfoState(this);
+    this.editor = new DataCubeEditorState(this);
+    this.grid = new DataCubeGridState(this);
+    this.filter = new DataCubeFilterEditorState(this);
+    this.extend = new DataCubeExtendManagerState(this);
+  }
+
+  newTask(name: string) {
+    const task = new DataCubeTask(name);
+    this.runningTasks.set(task.uuid, task);
+    return task;
+  }
+
+  endTask(task: DataCubeTask) {
+    task.end();
+    this.runningTasks.delete(task.uuid);
+    return task;
+  }
+
+  async initialize() {
+    const task = this.newTask('Initializing');
+    try {
+      await Promise.all(
+        [
+          this.info,
+          this.editor,
+          this.grid,
+          this.grid.controller,
+          this.filter,
+          this.extend,
+        ].map(async (state) => {
+          this.snapshotManager.registerSubscriber(state);
+        }),
+      );
+      const result = await this.engine.getBaseQuery();
+      const initialSnapshot = validateAndBuildQuerySnapshot(
+        result.partialQuery,
+        result.sourceQuery,
+        result.query,
+      );
+      initialSnapshot.timestamp = result.timestamp;
+      this.snapshotManager.broadcastSnapshot(initialSnapshot);
+    } catch (error: unknown) {
+      assertErrorThrown(error);
+      this.application.alertAction({
+        message: `Initialization Failure: ${error.message}`,
+        prompt: `Resolve the issue and reload the application.`,
+        type: AlertType.ERROR,
+        actions: [],
+      });
+    } finally {
+      this.endTask(task);
+    }
+  }
+}

package/src/stores/core/DataCubeConfiguration.ts

@@ -0,0 +1,240 @@
+/**
+ * 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 {
+  DEFAULT_BACKGROUND_COLOR,
+  DEFAULT_ERROR_FOREGROUND_COLOR,
+  DEFAULT_FOREGROUND_COLOR,
+  DEFAULT_NEGATIVE_FOREGROUND_COLOR,
+  DEFAULT_ROW_HIGHLIGHT_BACKGROUND_COLOR,
+  DEFAULT_ZERO_FOREGROUND_COLOR,
+  DEFAULT_GRID_LINE_COLOR,
+  DEFAULT_FONT_FAMILY,
+  DEFAULT_FONT_SIZE,
+  DEFAULT_FONT_BOLD,
+  DEFAULT_FONT_ITALIC,
+  DEFAULT_FONT_STRIKETHROUGH,
+  DEFAULT_TEXT_ALIGN,
+  DEFAULT_FONT_UNDERLINED,
+  DEFAULT_FONT_CASE,
+  DataCubeColumnKind,
+  type DataCubeFont,
+  type DataCubeFontTextAlignment,
+  type DataCubeFontFormatUnderlineVariant,
+  type DataCubeNumberScale,
+  type DataCubeSelectionStat,
+  type DataCubeColumnPinPlacement,
+  type DataCubeFontCase,
+  type DataCubeOperationValue,
+} from './DataCubeQueryEngine.js';
+import { SerializationFactory, usingModelSchema } from '@finos/legend-shared';
+import { createModelSchema, list, optional, primitive, raw } from 'serializr';
+
+export type DataCubeConfigurationColorKey =
+  | 'normal'
+  | 'zero'
+  | 'negative'
+  | 'error';
+
+export class DataCubeColumnConfiguration {
+  name: string;
+  type: string;
+
+  kind: DataCubeColumnKind = DataCubeColumnKind.DIMENSION;
+  displayName?: string | undefined;
+
+  decimals?: number | undefined;
+  displayCommas = false;
+  negativeNumberInParens = false;
+  numberScale?: DataCubeNumberScale | undefined;
+  missingValueDisplayText?: string | undefined;
+
+  fontFamily?: DataCubeFont | undefined;
+  fontSize?: number | undefined;
+  fontBold?: boolean | undefined;
+  fontItalic?: boolean | undefined;
+  fontUnderline?: DataCubeFontFormatUnderlineVariant | undefined;
+  fontStrikethrough?: boolean | undefined;
+  fontCase?: DataCubeFontCase | undefined;
+  textAlign?: DataCubeFontTextAlignment | undefined;
+  normalForegroundColor?: string | undefined;
+  negativeForegroundColor?: string | undefined;
+  zeroForegroundColor?: string | undefined;
+  errorForegroundColor?: string | undefined;
+  normalBackgroundColor?: string | undefined;
+  negativeBackgroundColor?: string | undefined;
+  zeroBackgroundColor?: string | undefined;
+  errorBackgroundColor?: string | undefined;
+
+  /**
+   * Used to indicate if the column is to be fetched as part of the result
+   * or to be used in aggregation. This would influence data-fetching.
+   */
+  isSelected = true;
+  /**
+   * Unlike `isSelected`, this is used to indicate if the column is to be displayed
+   * in the grid or not, this would not influence data-fetching, i.e. the column
+   * is still fetched and used in various part of the queries, but the column associated
+   * will not be displayed in the result grid.
+   */
+  hideFromView = false;
+  blur = false;
+
+  fixedWidth?: number | undefined;
+  minWidth?: number | undefined;
+  maxWidth?: number | undefined;
+  pinned?: DataCubeColumnPinPlacement | undefined;
+
+  displayAsLink = false;
+  linkLabelParameter?: string | undefined;
+
+  // NOTE: these configurations, when changed, would potentially trigger data-fetching
+  aggregateOperator!: string;
+  aggregationParameters: DataCubeOperationValue[] = [];
+  excludedFromHorizontalPivot = true; // this agrees with default column kind set as Dimension
+  horizontalPivotSortFunction?: string | undefined;
+
+  constructor(name: string, type: string) {
+    this.name = name;
+    this.type = type;
+  }
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(DataCubeColumnConfiguration, {
+      aggregateOperator: primitive(),
+      aggregationParameters: list(raw()),
+      blur: primitive(),
+      decimals: optional(primitive()),
+      displayAsLink: primitive(),
+      displayCommas: primitive(),
+      displayName: optional(primitive()),
+      errorBackgroundColor: optional(primitive()),
+      errorForegroundColor: optional(primitive()),
+      excludedFromHorizontalPivot: primitive(),
+      fixedWidth: optional(primitive()),
+      fontBold: optional(primitive()),
+      fontCase: optional(primitive()),
+      fontFamily: optional(primitive()),
+      fontItalic: optional(primitive()),
+      fontSize: optional(primitive()),
+      fontStrikethrough: optional(primitive()),
+      fontUnderline: optional(primitive()),
+      hideFromView: primitive(),
+      horizontalPivotSortFunction: optional(primitive()),
+      isSelected: primitive(),
+      kind: primitive(),
+      linkLabelParameter: optional(primitive()),
+      maxWidth: optional(primitive()),
+      minWidth: optional(primitive()),
+      missingValueDisplayText: optional(primitive()),
+      name: primitive(),
+      negativeBackgroundColor: optional(primitive()),
+      negativeForegroundColor: optional(primitive()),
+      normalBackgroundColor: optional(primitive()),
+      normalForegroundColor: optional(primitive()),
+      negativeNumberInParens: primitive(),
+      numberScale: optional(primitive()),
+      pinned: optional(primitive()),
+      textAlign: optional(primitive()),
+      type: primitive(),
+      zeroBackgroundColor: optional(primitive()),
+      zeroForegroundColor: optional(primitive()),
+    }),
+  );
+}
+
+export class DataCubeConfiguration {
+  description?: string | undefined;
+  columns: DataCubeColumnConfiguration[] = [];
+
+  showTreeLines = false;
+  showHorizontalGridLines = false;
+  showVerticalGridLines = true;
+  gridLineColor = DEFAULT_GRID_LINE_COLOR;
+
+  fontFamily = DEFAULT_FONT_FAMILY;
+  fontSize = DEFAULT_FONT_SIZE;
+  fontBold = DEFAULT_FONT_BOLD;
+  fontItalic = DEFAULT_FONT_ITALIC;
+  fontUnderline?: DataCubeFontFormatUnderlineVariant | undefined =
+    DEFAULT_FONT_UNDERLINED;
+  fontStrikethrough = DEFAULT_FONT_STRIKETHROUGH;
+  fontCase?: DataCubeFontCase | undefined = DEFAULT_FONT_CASE;
+  textAlign = DEFAULT_TEXT_ALIGN;
+  normalForegroundColor = DEFAULT_FOREGROUND_COLOR;
+  negativeForegroundColor = DEFAULT_NEGATIVE_FOREGROUND_COLOR;
+  zeroForegroundColor = DEFAULT_ZERO_FOREGROUND_COLOR;
+  errorForegroundColor = DEFAULT_ERROR_FOREGROUND_COLOR;
+  normalBackgroundColor = DEFAULT_BACKGROUND_COLOR;
+  negativeBackgroundColor = DEFAULT_BACKGROUND_COLOR;
+  zeroBackgroundColor = DEFAULT_BACKGROUND_COLOR;
+  errorBackgroundColor = DEFAULT_BACKGROUND_COLOR;
+
+  alternateRows = false;
+  alternateRowsStandardMode = true;
+  alternateRowsColor = DEFAULT_ROW_HIGHLIGHT_BACKGROUND_COLOR;
+  alternateRowsCount = 1;
+
+  selectionStats: DataCubeSelectionStat[] = [];
+  showWarningForTruncatedResult = true;
+
+  // NOTE: these configurations, when changed, would potentially trigger data-fetching
+  initialExpandLevel?: number | undefined;
+  showRootAggregation = false;
+  showLeafCount = false;
+  pivotTotalColumnPlacement?: DataCubeColumnPinPlacement | undefined;
+  treeGroupSortFunction?: string | undefined;
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(DataCubeConfiguration, {
+      alternateRows: primitive(),
+      alternateRowsColor: primitive(),
+      alternateRowsCount: primitive(),
+      alternateRowsStandardMode: primitive(),
+      columns: list(
+        usingModelSchema(DataCubeColumnConfiguration.serialization.schema),
+      ),
+      errorBackgroundColor: primitive(),
+      errorForegroundColor: primitive(),
+      description: optional(primitive()),
+      fontBold: primitive(),
+      fontCase: optional(primitive()),
+      fontFamily: primitive(),
+      fontItalic: primitive(),
+      fontSize: primitive(),
+      fontStrikethrough: primitive(),
+      fontUnderline: optional(primitive()),
+      gridLineColor: primitive(),
+      initialExpandLevel: optional(primitive()),
+      negativeBackgroundColor: primitive(),
+      negativeForegroundColor: primitive(),
+      normalBackgroundColor: primitive(),
+      normalForegroundColor: primitive(),
+      pivotTotalColumnPlacement: optional(primitive()),
+      selectionStats: list(primitive()),
+      showHorizontalGridLines: primitive(),
+      showLeafCount: primitive(),
+      showRootAggregation: primitive(),
+      showTreeLines: primitive(),
+      showVerticalGridLines: primitive(),
+      showWarningForTruncatedResult: primitive(),
+      textAlign: primitive(),
+      treeGroupSortFunction: optional(primitive()),
+      zeroBackgroundColor: primitive(),
+      zeroForegroundColor: primitive(),
+    }),
+  );
+}

package/src/stores/core/DataCubeConfigurationBuilder.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 { PRIMITIVE_TYPE } from '@finos/legend-graph';
+import {
+  DataCubeColumnConfiguration,
+  DataCubeConfiguration,
+} from './DataCubeConfiguration.js';
+import {
+  DataCubeAggregateOperator,
+  DataCubeColumnKind,
+  DataCubeFontTextAlignment,
+} from './DataCubeQueryEngine.js';
+
+export function buildDefaultColumnConfiguration(column: {
+  name: string;
+  type: string;
+}): DataCubeColumnConfiguration {
+  const { name, type } = column;
+  const config = new DataCubeColumnConfiguration(name, type);
+  switch (type) {
+    case PRIMITIVE_TYPE.NUMBER:
+    case PRIMITIVE_TYPE.INTEGER:
+    case PRIMITIVE_TYPE.DECIMAL:
+    case PRIMITIVE_TYPE.FLOAT: {
+      config.kind = DataCubeColumnKind.MEASURE;
+      config.decimals = type === PRIMITIVE_TYPE.INTEGER ? 0 : 2;
+      config.displayCommas = true;
+      config.negativeNumberInParens = true;
+      config.textAlign = DataCubeFontTextAlignment.RIGHT; // always align number to the right
+      config.excludedFromHorizontalPivot = false;
+      config.aggregateOperator = DataCubeAggregateOperator.SUM;
+      break;
+    }
+    default: {
+      config.kind = DataCubeColumnKind.DIMENSION;
+      config.excludedFromHorizontalPivot = true;
+      config.aggregateOperator = DataCubeAggregateOperator.UNIQUE;
+      break;
+    }
+  }
+  return config;
+}
+
+export function buildDefaultConfiguration(
+  columns: { name: string; type: string }[],
+): DataCubeConfiguration {
+  const configuration = new DataCubeConfiguration();
+  configuration.columns = columns.map((column) =>
+    buildDefaultColumnConfiguration(column),
+  );
+  return configuration;
+}

package/src/stores/core/DataCubeInfoState.ts

@@ -0,0 +1,61 @@
+/**
+ * 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 { DataCubeQuerySnapshotController } from './DataCubeQuerySnapshotManager.js';
+import type { DataCubeQuerySnapshot } from './DataCubeQuerySnapshot.js';
+import type { DataCubeQuery } from '../engine/DataCubeQuery.js';
+import { formatDate } from '@finos/legend-shared';
+import { DEFAULT_REPORT_NAME } from './DataCubeQueryEngine.js';
+
+/**
+ * Unlike other query editor state, this state does not support making any
+ * modification to the query, it simplies subscribe to extract information
+ * from the latest snapshot to help display latest static info about the query.
+ */
+export class DataCubeInfoState extends DataCubeQuerySnapshotController {
+  baseQuery!: DataCubeQuery;
+  name = DEFAULT_REPORT_NAME;
+  private editionStartTime?: number | undefined;
+
+  constructor(view: DataCubeViewState) {
+    super(view);
+
+    makeObservable<DataCubeInfoState, 'setName'>(this, {
+      name: observable,
+      setName: action,
+    });
+  }
+
+  private setName(val: string) {
+    this.name = val;
+  }
+
+  override async applySnapshot(
+    snapshot: DataCubeQuerySnapshot,
+    previousSnapshot: DataCubeQuerySnapshot | undefined,
+  ) {
+    const data = snapshot.data;
+    this.setName(data.name);
+    if (!this.editionStartTime) {
+      this.editionStartTime = snapshot.timestamp;
+    }
+    this.view.application.setWindowTitle(
+      `\u229E ${data.name}${this.editionStartTime ? ` - ${formatDate(new Date(this.editionStartTime), 'HH:mm:ss EEE MMM dd yyyy')}` : ''}`,
+    );
+  }
+}