@finos/legend-data-cube 0.0.2

package/src/stores/core/DataCubeQuerySnapshotManager.ts

@@ -0,0 +1,148 @@
+/**
+ * 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 { DataCubeViewState } from '../DataCubeViewState.js';
+import type { DataCubeQuerySnapshot } from './DataCubeQuerySnapshot.js';
+import {
+  IllegalStateError,
+  assertErrorThrown,
+  deepDiff,
+  guaranteeNonNullable,
+} from '@finos/legend-shared';
+import type { DataCubeQuery } from '../engine/DataCubeQuery.js';
+
+// TODO: set a stack depth when we implement undo/redo
+// const DATA_CUBE_MAX_SNAPSHOT_COUNT = 100;
+
+interface DataCubeQuerySnapshotSubscriber {
+  getLatestSnapshot(): DataCubeQuerySnapshot | undefined;
+  receiveSnapshot(snapshot: DataCubeQuerySnapshot): Promise<void>;
+}
+
+export abstract class DataCubeQuerySnapshotController
+  implements DataCubeQuerySnapshotSubscriber
+{
+  readonly view!: DataCubeViewState;
+
+  private latestSnapshot: DataCubeQuerySnapshot | undefined;
+
+  constructor(view: DataCubeViewState) {
+    this.view = view;
+  }
+
+  abstract applySnapshot(
+    snapshot: DataCubeQuerySnapshot,
+    previousSnapshot: DataCubeQuerySnapshot | undefined,
+  ): Promise<void>;
+
+  async receiveSnapshot(snapshot: DataCubeQuerySnapshot) {
+    const previousSnapshot = this.latestSnapshot;
+    this.latestSnapshot = snapshot;
+    await this.applySnapshot(snapshot, previousSnapshot);
+  }
+
+  publishSnapshot(snapshot: DataCubeQuerySnapshot) {
+    if (this.view.engine.enableDebugMode) {
+      this.view.application.debugProcess(
+        `New Snapshot`,
+        '\nSnapshot',
+        snapshot,
+        '\nPrevious Snapshot',
+        this.latestSnapshot ?? {},
+        '\nDiff',
+        deepDiff(snapshot, this.latestSnapshot ?? {}),
+      );
+    }
+    this.latestSnapshot = snapshot;
+    this.view.snapshotManager.broadcastSnapshot(snapshot);
+  }
+
+  getLatestSnapshot() {
+    return this.latestSnapshot;
+  }
+}
+
+export class DataCubeQuerySnapshotManager {
+  private readonly view: DataCubeViewState;
+  private readonly subscribers: DataCubeQuerySnapshotSubscriber[] = [];
+  private readonly snapshots: DataCubeQuerySnapshot[] = [];
+
+  private _initialSnapshot: DataCubeQuerySnapshot | undefined;
+  private _initialQuery: DataCubeQuery | undefined;
+
+  constructor(view: DataCubeViewState) {
+    this.view = view;
+  }
+
+  get currentSnapshot() {
+    return guaranteeNonNullable(this.snapshots[this.snapshots.length - 1]);
+  }
+
+  registerSubscriber(subscriber: DataCubeQuerySnapshotSubscriber) {
+    this.subscribers.push(subscriber);
+  }
+
+  initialize(
+    initialSnapshot: DataCubeQuerySnapshot,
+    initialQuery: DataCubeQuery,
+  ) {
+    if (this._initialSnapshot || this._initialQuery) {
+      throw new IllegalStateError(
+        `Snapshot manager has already been initialized`,
+      );
+    }
+    this._initialSnapshot = initialSnapshot;
+    this._initialQuery = initialQuery;
+  }
+
+  get initialSnapshot() {
+    return guaranteeNonNullable(
+      this._initialSnapshot,
+      `Snapshot manager has not been initialized`,
+    );
+  }
+
+  get initialQuery() {
+    return guaranteeNonNullable(
+      this._initialQuery,
+      `Snapshot manager has not been initialized`,
+    );
+  }
+
+  broadcastSnapshot(snapshot: DataCubeQuerySnapshot) {
+    if (!snapshot.isFinalized()) {
+      this.view.application.logIllegalStateError(
+        `Snapshot must be finalized before broadcasting`,
+      );
+      return;
+    }
+    this.snapshots.push(snapshot);
+    this.subscribers.forEach((subscriber) => {
+      const currentSnapshot = subscriber.getLatestSnapshot();
+      if (currentSnapshot?.uuid !== snapshot.uuid) {
+        subscriber.receiveSnapshot(snapshot).catch((error: unknown) => {
+          assertErrorThrown(error);
+          this.view.application.logIllegalStateError(
+            `Error occured while subscribers receiving and applying new snapshot should be handled gracefully`,
+            error,
+          );
+        });
+      }
+    });
+  }
+
+  // TODO: replace snapshot (for minor modifications such as adjusting the cast columns)
+}

package/src/stores/core/aggregation/DataCubeQueryAggregateOperation.ts

@@ -0,0 +1,47 @@
+/**
+ * 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 { guaranteeNonNullable } from '@finos/legend-shared';
+import type { DataCubeQuerySnapshotColumn } from '../DataCubeQuerySnapshot.js';
+import { type V1_ColSpec } from '@finos/legend-graph';
+import type { DataCubeColumnConfiguration } from '../DataCubeConfiguration.js';
+
+// --------------------------------- UTILITIES ---------------------------------
+
+export function getAggregateOperation(
+  operator: string,
+  aggregateOperations: DataCubeQueryAggregateOperation[],
+) {
+  return guaranteeNonNullable(
+    aggregateOperations.find((op) => op.operator === operator),
+    `Can't find aggregate operation '${operator}'`,
+  );
+}
+
+// --------------------------------- CONTRACT ---------------------------------
+
+export abstract class DataCubeQueryAggregateOperation {
+  abstract get label(): React.ReactNode;
+  abstract get textLabel(): string;
+  abstract get description(): string;
+  abstract get operator(): string;
+
+  abstract isCompatibleWithColumn(column: DataCubeQuerySnapshotColumn): boolean;
+
+  abstract buildAggregateColumn(
+    column: DataCubeColumnConfiguration,
+  ): V1_ColSpec | undefined;
+}

package/src/stores/core/aggregation/DataCubeQueryAggregateOperation__Average.tsx

@@ -0,0 +1,52 @@
+/**
+ * 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 { DataCubeQuerySnapshotColumn } from '../DataCubeQuerySnapshot.js';
+import { DataCubeQueryAggregateOperation } from './DataCubeQueryAggregateOperation.js';
+import {
+  DataCubeAggregateOperator,
+  DataCubeColumnDataType,
+  DataCubeFunction,
+  ofDataType,
+} from '../DataCubeQueryEngine.js';
+import { _aggCol_basic } from '../DataCubeQueryBuilderUtils.js';
+import type { DataCubeColumnConfiguration } from '../DataCubeConfiguration.js';
+
+export class DataCubeQueryAggregateOperation__Average extends DataCubeQueryAggregateOperation {
+  override get label() {
+    return 'avg';
+  }
+
+  override get textLabel() {
+    return 'average';
+  }
+
+  override get description() {
+    return 'average';
+  }
+
+  override get operator(): string {
+    return DataCubeAggregateOperator.AVERAGE;
+  }
+
+  isCompatibleWithColumn(column: DataCubeQuerySnapshotColumn) {
+    return ofDataType(column.type, [DataCubeColumnDataType.NUMBER]);
+  }
+
+  buildAggregateColumn(column: DataCubeColumnConfiguration) {
+    return _aggCol_basic(column, DataCubeFunction.AVERAGE);
+  }
+}

package/src/stores/core/aggregation/DataCubeQueryAggregateOperation__Count.tsx

@@ -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 type { DataCubeQuerySnapshotColumn } from '../DataCubeQuerySnapshot.js';
+import { DataCubeQueryAggregateOperation } from './DataCubeQueryAggregateOperation.js';
+import {
+  DataCubeAggregateOperator,
+  DataCubeColumnDataType,
+  DataCubeFunction,
+  ofDataType,
+} from '../DataCubeQueryEngine.js';
+import { _aggCol_basic } from '../DataCubeQueryBuilderUtils.js';
+import type { DataCubeColumnConfiguration } from '../DataCubeConfiguration.js';
+
+export class DataCubeQueryAggregateOperation__Count extends DataCubeQueryAggregateOperation {
+  override get label() {
+    return 'count';
+  }
+
+  override get textLabel() {
+    return 'count';
+  }
+
+  override get description() {
+    return 'count';
+  }
+
+  override get operator(): string {
+    return DataCubeAggregateOperator.COUNT;
+  }
+
+  isCompatibleWithColumn(column: DataCubeQuerySnapshotColumn) {
+    return ofDataType(column.type, [
+      // NOTE: technically all data types are suported,
+      // but we can't because we must preserve the type
+      // of the original column
+      //
+      // typically, what users usually do is to create a "dummy"
+      // extended column of value=1 and aggregate on that for the count
+
+      DataCubeColumnDataType.NUMBER,
+    ]);
+  }
+
+  buildAggregateColumn(column: DataCubeColumnConfiguration) {
+    return _aggCol_basic(column, DataCubeFunction.COUNT);
+  }
+}

package/src/stores/core/aggregation/DataCubeQueryAggregateOperation__First.tsx

@@ -0,0 +1,57 @@
+/**
+ * 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 { DataCubeQuerySnapshotColumn } from '../DataCubeQuerySnapshot.js';
+import { DataCubeQueryAggregateOperation } from './DataCubeQueryAggregateOperation.js';
+import {
+  DataCubeAggregateOperator,
+  DataCubeColumnDataType,
+  DataCubeFunction,
+  ofDataType,
+} from '../DataCubeQueryEngine.js';
+import { _aggCol_basic } from '../DataCubeQueryBuilderUtils.js';
+import type { DataCubeColumnConfiguration } from '../DataCubeConfiguration.js';
+
+export class DataCubeQueryAggregateOperation__First extends DataCubeQueryAggregateOperation {
+  override get label() {
+    return 'first';
+  }
+
+  override get textLabel() {
+    return 'first';
+  }
+
+  override get description() {
+    return 'first';
+  }
+
+  override get operator(): string {
+    return DataCubeAggregateOperator.FIRST;
+  }
+
+  isCompatibleWithColumn(column: DataCubeQuerySnapshotColumn) {
+    return ofDataType(column.type, [
+      DataCubeColumnDataType.TEXT,
+      DataCubeColumnDataType.NUMBER,
+      DataCubeColumnDataType.DATE,
+      DataCubeColumnDataType.TIME,
+    ]);
+  }
+
+  buildAggregateColumn(column: DataCubeColumnConfiguration) {
+    return _aggCol_basic(column, DataCubeFunction.FIRST);
+  }
+}

package/src/stores/core/aggregation/DataCubeQueryAggregateOperation__JoinStrings.tsx

@@ -0,0 +1,81 @@
+/**
+ * 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 { DataCubeQuerySnapshotColumn } from '../DataCubeQuerySnapshot.js';
+import { PRIMITIVE_TYPE } from '@finos/legend-graph';
+import { DataCubeQueryAggregateOperation } from './DataCubeQueryAggregateOperation.js';
+import {
+  DataCubeAggregateOperator,
+  DataCubeColumnDataType,
+  DataCubeFunction,
+  ofDataType,
+} from '../DataCubeQueryEngine.js';
+import {
+  _colSpec,
+  _function,
+  _functionName,
+  _lambda,
+  _primitiveValue,
+  _property,
+  _var,
+} from '../DataCubeQueryBuilderUtils.js';
+import type { DataCubeColumnConfiguration } from '../DataCubeConfiguration.js';
+
+export class DataCubeQueryAggregateOperation__JoinStrings extends DataCubeQueryAggregateOperation {
+  override get label() {
+    return 'strjoin';
+  }
+
+  override get textLabel() {
+    return 'join strings';
+  }
+
+  override get description() {
+    return 'join strings';
+  }
+
+  override get operator(): string {
+    return DataCubeAggregateOperator.JOIN_STRINGS;
+  }
+
+  isCompatibleWithColumn(column: DataCubeQuerySnapshotColumn) {
+    return ofDataType(column.type, [
+      // NOTE: technically all data types should be suported,
+      // i.e. we can use meta::pure::functions::string::makeString
+      // instead, but we can't because must preserve the type of
+      // the original column
+      DataCubeColumnDataType.TEXT,
+    ]);
+  }
+
+  buildAggregateColumn(column: DataCubeColumnConfiguration) {
+    const variable = _var();
+    return _colSpec(
+      column.name,
+      _lambda([variable], [_property(column.name, variable)]),
+      _lambda(
+        [variable],
+        [
+          _function(_functionName(DataCubeFunction.JOIN_STRINGS), [
+            variable,
+            // TODO: we might want to support customizing the delimiter in this case
+            _primitiveValue(PRIMITIVE_TYPE.STRING, ','),
+          ]),
+        ],
+      ),
+    );
+  }
+}

package/src/stores/core/aggregation/DataCubeQueryAggregateOperation__Last.tsx

@@ -0,0 +1,57 @@
+/**
+ * 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 { DataCubeQuerySnapshotColumn } from '../DataCubeQuerySnapshot.js';
+import { DataCubeQueryAggregateOperation } from './DataCubeQueryAggregateOperation.js';
+import {
+  DataCubeAggregateOperator,
+  DataCubeColumnDataType,
+  DataCubeFunction,
+  ofDataType,
+} from '../DataCubeQueryEngine.js';
+import { _aggCol_basic } from '../DataCubeQueryBuilderUtils.js';
+import type { DataCubeColumnConfiguration } from '../DataCubeConfiguration.js';
+
+export class DataCubeQueryAggregateOperation__Last extends DataCubeQueryAggregateOperation {
+  override get label() {
+    return 'last';
+  }
+
+  override get textLabel() {
+    return 'last';
+  }
+
+  override get description() {
+    return 'last';
+  }
+
+  override get operator(): string {
+    return DataCubeAggregateOperator.LAST;
+  }
+
+  isCompatibleWithColumn(column: DataCubeQuerySnapshotColumn) {
+    return ofDataType(column.type, [
+      DataCubeColumnDataType.TEXT,
+      DataCubeColumnDataType.NUMBER,
+      DataCubeColumnDataType.DATE,
+      DataCubeColumnDataType.TIME,
+    ]);
+  }
+
+  buildAggregateColumn(column: DataCubeColumnConfiguration) {
+    return _aggCol_basic(column, DataCubeFunction.LAST);
+  }
+}

package/src/stores/core/aggregation/DataCubeQueryAggregateOperation__Max.tsx

@@ -0,0 +1,52 @@
+/**
+ * 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 { DataCubeQuerySnapshotColumn } from '../DataCubeQuerySnapshot.js';
+import { DataCubeQueryAggregateOperation } from './DataCubeQueryAggregateOperation.js';
+import {
+  DataCubeAggregateOperator,
+  DataCubeColumnDataType,
+  DataCubeFunction,
+  ofDataType,
+} from '../DataCubeQueryEngine.js';
+import { _aggCol_basic } from '../DataCubeQueryBuilderUtils.js';
+import type { DataCubeColumnConfiguration } from '../DataCubeConfiguration.js';
+
+export class DataCubeQueryAggregateOperation__Max extends DataCubeQueryAggregateOperation {
+  override get label() {
+    return 'max';
+  }
+
+  override get textLabel() {
+    return 'max';
+  }
+
+  override get description() {
+    return 'max';
+  }
+
+  override get operator(): string {
+    return DataCubeAggregateOperator.MAX;
+  }
+
+  isCompatibleWithColumn(column: DataCubeQuerySnapshotColumn) {
+    return ofDataType(column.type, [DataCubeColumnDataType.NUMBER]);
+  }
+
+  buildAggregateColumn(column: DataCubeColumnConfiguration) {
+    return _aggCol_basic(column, DataCubeFunction.MAX);
+  }
+}

package/src/stores/core/aggregation/DataCubeQueryAggregateOperation__Min.tsx

@@ -0,0 +1,52 @@
+/**
+ * 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 { DataCubeQuerySnapshotColumn } from '../DataCubeQuerySnapshot.js';
+import { DataCubeQueryAggregateOperation } from './DataCubeQueryAggregateOperation.js';
+import {
+  DataCubeAggregateOperator,
+  DataCubeColumnDataType,
+  DataCubeFunction,
+  ofDataType,
+} from '../DataCubeQueryEngine.js';
+import { _aggCol_basic } from '../DataCubeQueryBuilderUtils.js';
+import type { DataCubeColumnConfiguration } from '../DataCubeConfiguration.js';
+
+export class DataCubeQueryAggregateOperation__Min extends DataCubeQueryAggregateOperation {
+  override get label() {
+    return 'min';
+  }
+
+  override get textLabel() {
+    return 'min';
+  }
+
+  override get description() {
+    return 'min';
+  }
+
+  override get operator(): string {
+    return DataCubeAggregateOperator.MIN;
+  }
+
+  isCompatibleWithColumn(column: DataCubeQuerySnapshotColumn) {
+    return ofDataType(column.type, [DataCubeColumnDataType.NUMBER]);
+  }
+
+  buildAggregateColumn(column: DataCubeColumnConfiguration) {
+    return _aggCol_basic(column, DataCubeFunction.MIN);
+  }
+}

package/src/stores/core/aggregation/DataCubeQueryAggregateOperation__StdDevPopulation.tsx

@@ -0,0 +1,55 @@
+/**
+ * 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 { DataCubeQuerySnapshotColumn } from '../DataCubeQuerySnapshot.js';
+import { DataCubeQueryAggregateOperation } from './DataCubeQueryAggregateOperation.js';
+import {
+  DataCubeAggregateOperator,
+  DataCubeColumnDataType,
+  DataCubeFunction,
+  ofDataType,
+} from '../DataCubeQueryEngine.js';
+import { _aggCol_basic } from '../DataCubeQueryBuilderUtils.js';
+import type { DataCubeColumnConfiguration } from '../DataCubeConfiguration.js';
+
+export class DataCubeQueryAggregateOperation__StdDevPopulation extends DataCubeQueryAggregateOperation {
+  override get label() {
+    return 'std';
+  }
+
+  override get textLabel() {
+    return 'standard deviation (population)';
+  }
+
+  override get description() {
+    return 'standard deviation (population)';
+  }
+
+  override get operator(): string {
+    return DataCubeAggregateOperator.STANDARD_DEVIATION_POPULATION;
+  }
+
+  isCompatibleWithColumn(column: DataCubeQuerySnapshotColumn) {
+    return ofDataType(column.type, [DataCubeColumnDataType.NUMBER]);
+  }
+
+  buildAggregateColumn(column: DataCubeColumnConfiguration) {
+    return _aggCol_basic(
+      column,
+      DataCubeFunction.STANDARD_DEVIATION_POPULATION,
+    );
+  }
+}