@finos/legend-data-cube 0.2.0 → 0.2.2

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

@@ -17,11 +17,23 @@
 import type { CellDoubleClickedEvent } from 'ag-grid-community';
 import type { DataCubeConfiguration } from '../../core/model/DataCubeConfiguration.js';
 import {
+  customList,
   guaranteeNonNullable,
   guaranteeType,
   hashArray,
+  SerializationFactory,
+  usingModelSchema,
   type Hashable,
+  type PlainObject,
+  type Writable,
 } from '@finos/legend-shared';
+import {
+  createModelSchema,
+  deserialize,
+  list,
+  primitive,
+  serialize,
+} from 'serializr';
 
 export const DIMENSIONAL_L0_COLUMN = 'ALL';
 
@@ -31,20 +43,33 @@ enum DimensionalNodeHashType {
   DIMENSIONAL_TREE = 'dimensionalTree',
 }
 
-export class DataCubeDimensionalTree implements Hashable {
-  rootNodes: DataCubeDimensionalNode[];
+export class DataCubeDimensionalGroupByNode implements Hashable {
+  column: string;
+  filter: string;
+  dimension: string;
 
-  constructor(rootNodes: DataCubeDimensionalNode[]) {
-    this.rootNodes = rootNodes;
+  constructor(column: string, filter: string, dimension: string) {
+    this.column = column;
+    this.filter = filter;
+    this.dimension = dimension;
   }
 
-  // TODO: improve hashing
   get hashCode(): string {
     return hashArray([
-      DimensionalNodeHashType.DIMENSIONAL_TREE,
-      hashArray(this.rootNodes),
+      DimensionalNodeHashType.GROUP_BY_NODE,
+      this.column,
+      this.filter,
+      this.dimension,
     ]);
   }
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(DataCubeDimensionalGroupByNode, {
+      column: primitive(),
+      filter: primitive(),
+      dimension: primitive(),
+    }),
+  );
 }
 
 export class DataCubeDimensionalNode implements Hashable {
@@ -72,27 +97,79 @@ export class DataCubeDimensionalNode implements Hashable {
       hashArray(this.groupByNodes),
     ]);
   }
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(DataCubeDimensionalNode, {
+      column: primitive(),
+      dimension: primitive(),
+      childNodes: customList(
+        serializeDataCubeDimensionalNode,
+        deSerializeDataCubeDimensionalNode,
+      ),
+      groupByNodes: list(
+        usingModelSchema(DataCubeDimensionalGroupByNode.serialization.schema),
+      ),
+    }),
+  );
 }
 
-export class DataCubeDimensionalGroupByNode implements Hashable {
-  column: string;
-  filter: string;
-  dimension: string;
+const dataCubeDimensionalNodeModelSchema = createModelSchema(
+  DataCubeDimensionalNode,
+  {
+    column: primitive(),
+    dimension: primitive(),
+    childNodes: customList(
+      serializeDataCubeDimensionalNode,
+      deSerializeDataCubeDimensionalNode,
+    ),
+    groupByNodes: list(
+      usingModelSchema(DataCubeDimensionalGroupByNode.serialization.schema),
+    ),
+  },
+);
 
-  constructor(column: string, filter: string, dimension: string) {
-    this.column = column;
-    this.filter = filter;
-    this.dimension = dimension;
+function serializeDataCubeDimensionalNode(
+  protocol: DataCubeDimensionalNode,
+): PlainObject<DataCubeDimensionalNode> {
+  return serialize(dataCubeDimensionalNodeModelSchema, protocol);
+}
+
+function deSerializeDataCubeDimensionalNode(
+  plainObject: PlainObject<DataCubeDimensionalNode>,
+): DataCubeDimensionalNode {
+  return deserialize(dataCubeDimensionalNodeModelSchema, plainObject);
+}
+
+export class DataCubeDimensionalTree implements Hashable {
+  rootNodes: DataCubeDimensionalNode[];
+
+  constructor(rootNodes: DataCubeDimensionalNode[]) {
+    this.rootNodes = rootNodes;
   }
 
+  // TODO: improve hashing
   get hashCode(): string {
     return hashArray([
-      DimensionalNodeHashType.GROUP_BY_NODE,
-      this.column,
-      this.filter,
-      this.dimension,
+      DimensionalNodeHashType.DIMENSIONAL_TREE,
+      hashArray(this.rootNodes),
     ]);
   }
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(DataCubeDimensionalTree, {
+      rootNodes: list(
+        usingModelSchema(DataCubeDimensionalNode.serialization.schema),
+      ),
+    }),
+  );
+}
+
+export function cloneDimensionalTree(tree: DataCubeDimensionalTree) {
+  let clone = new DataCubeDimensionalTree([]);
+  (clone as Writable<DataCubeDimensionalTree>) = JSON.parse(
+    JSON.stringify(tree),
+  ) as DataCubeDimensionalTree;
+  return clone;
 }
 
 export class DataCubeDimensionalMetadata {
@@ -241,6 +318,74 @@ export function hydrateDataCubeDimensionalTree(
   return safeTree;
 }
 
+export function removeSubtreeNode(
+  tree: DataCubeDimensionalTree,
+  targetDimension: string,
+  targetColumn: string,
+  targetGroupByNodes: DataCubeDimensionalGroupByNode[],
+): boolean {
+  // Iterate only the roots of the matching dimension
+  for (const root of tree.rootNodes) {
+    if (root.dimension !== targetDimension) {
+      continue;
+    }
+
+    const found = findNodeWithParent(
+      root,
+      targetColumn,
+      targetGroupByNodes,
+      null,
+    );
+    if (!found) {
+      continue;
+    }
+
+    const { parent, index } = found;
+    if (parent) {
+      // remove from its parent’s childNodes
+      parent.childNodes.splice(index, 1);
+    } else {
+      // remove a root‐level node
+      // TODO: do nothing
+    }
+    return true; // removed successfully
+  }
+
+  return false; // no matching node found
+}
+
+function findNodeWithParent(
+  current: DataCubeDimensionalNode,
+  targetColumn: string,
+  targetGroupByNodes: DataCubeDimensionalGroupByNode[],
+  parent: DataCubeDimensionalNode | null = null,
+): { parent: DataCubeDimensionalNode | null; index: number } | null {
+  if (
+    current.column === targetColumn &&
+    findNodeByColumnOrGroup(current, targetColumn, targetGroupByNodes)
+  ) {
+    if (parent) {
+      const idx = parent.childNodes.findIndex((c) => c === current);
+      return { parent, index: idx };
+    } else {
+      // matched a root node
+      return { parent: null, index: -1 };
+    }
+  }
+  for (const child of current.childNodes) {
+    const found = findNodeWithParent(
+      child,
+      targetColumn,
+      targetGroupByNodes,
+      current,
+    );
+    if (found) {
+      return found;
+    }
+  }
+  return null;
+}
+
 function findNodeByColumnOrGroup(
   node: DataCubeDimensionalNode,
   targetColumn: string,
@@ -266,3 +411,28 @@ function findNodeByColumnOrGroup(
 
   return undefined;
 }
+
+function pathSignature(path: DataCubeDimensionalNode[]): string {
+  return path
+    .map((node) => {
+      const base = `${node.dimension}:${node.column}`;
+      if (node.groupByNodes.length > 0) {
+        const filters = node.groupByNodes
+          .map((g) => `${g.dimension}:${g.column}:${g.filter}`)
+          .join(',');
+        return `${base}->[${filters}]`;
+      } else {
+        return `${base}->[NO_FILTER]`;
+      }
+    })
+    .join('|');
+}
+
+//TODO: we can add oldPath signature directly in the snapshot
+export function findExtraPaths(
+  oldPaths: DataCubeDimensionalNode[][],
+  newPaths: DataCubeDimensionalNode[][],
+): DataCubeDimensionalNode[][] {
+  const oldSignatures = new Set(oldPaths.map(pathSignature));
+  return newPaths.filter((path) => !oldSignatures.has(pathSignature(path)));
+}

package/src/stores/view/grid/DataCubeGridMenuBuilder.tsx

@@ -34,6 +34,7 @@ import {
 } from '../../core/DataCubeQueryEngine.js';
 import {
   guaranteeIsNumber,
+  guaranteeNonNullable,
   isNonNullable,
   UnsupportedOperationError,
 } from '@finos/legend-shared';
@@ -51,6 +52,7 @@ import { _findCol } from '../../core/model/DataCubeColumn.js';
 import { useGridMenuItem, type CustomMenuItemProps } from 'ag-grid-react';
 import { FormBadge_WIP } from '../../../components/core/DataCubeFormUtils.js';
 import { DataCubeEvent } from '../../../__lib__/DataCubeEvent.js';
+import type { DataCubeDimensionalMetadata } from './DataCubeGridDimensionalTree.js';
 
 export function WIP_GridMenuItem({
   name,
@@ -1040,6 +1042,21 @@ export function generateDimensionalMenuBuilder(
 
     //TODO: add more menu items like sort,filter...
     return [
+      {
+        name: 'Zoom Out',
+        action: (param) => {
+          const data = param.node?.data.metadata as Map<
+            string,
+            DataCubeDimensionalMetadata
+          >;
+          view.grid
+            .retrieveDrilloutData(
+              data,
+              guaranteeNonNullable(params.column?.getColId()),
+            )
+            .catch((error) => dataCube.alertService.alertUnhandledError(error));
+        },
+      },
       {
         name: 'Export',
         subMenu: [

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

@@ -47,7 +47,13 @@ import {
   DataCubeGridMode,
 } from '../../core/DataCubeQueryEngine.js';
 import { DataCubeEvent } from '../../../__lib__/DataCubeEvent.js';
-import { hydrateDataCubeDimensionalTree } from './DataCubeGridDimensionalTree.js';
+import {
+  cloneDimensionalTree,
+  hydrateDataCubeDimensionalTree,
+  removeSubtreeNode,
+  type DataCubeDimensionalTree,
+  type DataCubeDimensionalMetadata,
+} from './DataCubeGridDimensionalTree.js';
 
 /**
  * This query editor state is responsible for syncing the internal state of ag-grid
@@ -286,30 +292,60 @@ export class DataCubeGridState extends DataCubeSnapshotController {
     const latestSnapshot = this.getLatestSnapshot();
 
     if (latestSnapshot) {
-      latestSnapshot.data.tree = hydrateDataCubeDimensionalTree(
-        DataCubeConfiguration.serialization.fromJson(
-          latestSnapshot.data.configuration,
-        ),
-      );
+      if (!latestSnapshot.data.dimensionalTree) {
+        latestSnapshot.data.dimensionalTree = hydrateDataCubeDimensionalTree(
+          DataCubeConfiguration.serialization.fromJson(
+            latestSnapshot.data.configuration,
+          ),
+        );
+      }
       await this._applyDimensionalSnapshot(latestSnapshot);
     }
   }
 
-  async retrieveDrilldownData(data: CellDoubleClickedEvent) {
+  async retrieveDrilloutData(
+    metadata: Map<string, DataCubeDimensionalMetadata>,
+    dimension: string,
+  ) {
     const latestSnapshot = guaranteeNonNullable(this.getLatestSnapshot());
-    latestSnapshot.data.tree = hydrateDataCubeDimensionalTree(
+    const previousTree = cloneDimensionalTree(
+      guaranteeNonNullable(latestSnapshot.data.dimensionalTree),
+    );
+    removeSubtreeNode(
+      guaranteeNonNullable(latestSnapshot.data.dimensionalTree),
+      dimension,
+      guaranteeNonNullable(metadata.get(dimension)?.column),
+      guaranteeNonNullable(metadata.get(dimension)?.groupByNodes),
+    );
+    await this._applyDimensionalSnapshot(latestSnapshot, previousTree);
+  }
+
+  async retrieveDrilldownData(data?: CellDoubleClickedEvent) {
+    const latestSnapshot = guaranteeNonNullable(this.getLatestSnapshot());
+    const previousTree = cloneDimensionalTree(
+      guaranteeNonNullable(latestSnapshot.data.dimensionalTree),
+    );
+    latestSnapshot.data.dimensionalTree = hydrateDataCubeDimensionalTree(
       DataCubeConfiguration.serialization.fromJson(
         latestSnapshot.data.configuration,
       ),
       data,
-      latestSnapshot.data.tree,
+      latestSnapshot.data.dimensionalTree,
     );
-    await this._applyDimensionalSnapshot(latestSnapshot);
+    await this._applyDimensionalSnapshot(latestSnapshot, previousTree);
   }
 
-  private async _applyDimensionalSnapshot(snapshot: DataCubeSnapshot) {
-    //TODO: only trigger when there is an actual change in tree
-    const result = await fetchDimensionalQueryRows(snapshot, this._view);
+  private async _applyDimensionalSnapshot(
+    snapshot: DataCubeSnapshot,
+    previousTree?: DataCubeDimensionalTree,
+  ) {
+    this._client?.hideOverlay();
+    this._client?.setGridOption(DataCubeClientModelOption.LOADING, true);
+    const result = await fetchDimensionalQueryRows(
+      snapshot,
+      this._view,
+      previousTree,
+    );
     this._client?.setGridOption(
       DataCubeClientModelOption.ROW_DATA,
       result.rowData,
@@ -318,6 +354,10 @@ export class DataCubeGridState extends DataCubeSnapshotController {
       DataCubeClientModelOption.COLUMN_DEFS,
       result.columnDefs,
     );
+    if (result.rowData.length === 0) {
+      this._client?.showNoRowsOverlay();
+    }
+    this._client?.setGridOption(DataCubeClientModelOption.LOADING, false);
     this.publishSnapshot(snapshot);
   }