@finos/legend-application-repl 0.0.31 → 0.0.33

package/src/stores/dataCube/DataCubeState.ts

@@ -14,16 +14,16 @@
  * limitations under the License.
  */
 
-import type { REPLStore } from './REPLStore.js';
+import type { REPLStore } from '../REPLStore.js';
 import { DataCubeGridState } from './grid/DataCubeGridState.js';
 import { DataCubeEditorState } from './editor/DataCubeEditorState.js';
 import { assertErrorThrown, uuid } from '@finos/legend-shared';
-import { DataCubeEngine } from './core/DataCubeEngine.js';
 import { DataCubeQuerySnapshotManager } from './core/DataCubeQuerySnapshotManager.js';
 import type { LegendREPLApplicationStore } from '../LegendREPLBaseStore.js';
 import { DataCubeCoreState } from './core/DataCubeCoreState.js';
 import { validateAndBuildQuerySnapshot } from './core/DataCubeQuerySnapshotBuilder.js';
 import { action, makeObservable, observable } from 'mobx';
+import type { DataCubeInfrastructure } from './DataCubeInfrastructure.js';
 
 export class DataCubeTask {
   uuid = uuid();
@@ -43,42 +43,42 @@ export class DataCubeTask {
 export class DataCubeState {
   readonly replStore: REPLStore;
   readonly application: LegendREPLApplicationStore;
-  readonly engine: DataCubeEngine;
+  readonly infrastructure: DataCubeInfrastructure;
   readonly snapshotManager: DataCubeQuerySnapshotManager;
 
   readonly core: DataCubeCoreState;
   readonly grid: DataCubeGridState;
   readonly editor: DataCubeEditorState;
 
-  readonly runningTaskes = new Map<string, DataCubeTask>();
+  readonly runningTasks = new Map<string, DataCubeTask>();
 
   constructor(replStore: REPLStore) {
     makeObservable(this, {
-      runningTaskes: observable,
+      runningTasks: observable,
       newTask: action,
       endTask: action,
     });
 
     this.replStore = replStore;
     this.application = replStore.applicationStore;
-    this.engine = new DataCubeEngine(this.replStore.client);
+    this.infrastructure = replStore.dataCubeInfrastructure;
 
     // NOTE: snapshot manager must be instantiated before subscribers
     this.snapshotManager = new DataCubeQuerySnapshotManager(this);
     this.core = new DataCubeCoreState(this);
-    this.grid = new DataCubeGridState(this);
     this.editor = new DataCubeEditorState(this);
+    this.grid = new DataCubeGridState(this);
   }
 
   newTask(name: string): DataCubeTask {
     const task = new DataCubeTask(name);
-    this.runningTaskes.set(task.uuid, task);
+    this.runningTasks.set(task.uuid, task);
     return task;
   }
 
   endTask(task: DataCubeTask): DataCubeTask {
     task.end();
-    this.runningTaskes.delete(task.uuid);
+    this.runningTasks.delete(task.uuid);
     return task;
   }
 
@@ -86,12 +86,14 @@ export class DataCubeState {
     const task = this.newTask('Initializing');
     try {
       await Promise.all(
-        [this.core, this.editor, this.grid].map(async (state) => {
-          this.snapshotManager.registerSubscriber(state);
-          await state.initialize();
-        }),
+        [this.core, this.editor, this.grid, this.grid.controller].map(
+          async (state) => {
+            this.snapshotManager.registerSubscriber(state);
+            await state.initialize();
+          },
+        ),
       );
-      const result = await this.engine.getBaseQuery();
+      const result = await this.infrastructure.engine.getBaseQuery();
       const initialSnapshot = validateAndBuildQuerySnapshot(
         result.partialQuery,
         result.sourceQuery,

package/src/stores/dataCube/core/DataCubeConfiguration.ts

@@ -14,26 +14,41 @@
  * limitations under the License.
  */
 
-import { TailwindCSSPalette } from '@finos/legend-art';
 import {
-  DataCubeColumnKind,
-  DataCubeFont,
-  DataCubeFontTextAlignment,
-  DEFAULT_ROW_BUFFER,
   DEFAULT_BACKGROUND_COLOR,
   DEFAULT_ERROR_FOREGROUND_COLOR,
   DEFAULT_FOREGROUND_COLOR,
   DEFAULT_NEGATIVE_FOREGROUND_COLOR,
   DEFAULT_ROW_HIGHLIGHT_BACKGROUND_COLOR,
   DEFAULT_ZERO_FOREGROUND_COLOR,
-  type DataCubeFontFormatUnderlinedVariant,
+  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 DataCubeAggregateFunction,
 } from './DataCubeQueryEngine.js';
 import { SerializationFactory, usingModelSchema } from '@finos/legend-shared';
 import { createModelSchema, list, optional, primitive } from 'serializr';
 
+export type DataCubeConfigurationColorKey =
+  | 'normal'
+  | 'zero'
+  | 'negative'
+  | 'error';
+
 export class DataCubeColumnConfiguration {
   name: string;
   type: string;
@@ -48,21 +63,22 @@ export class DataCubeColumnConfiguration {
 
   hPivotSortFunction?: string | undefined;
 
-  fontFamily = DataCubeFont.ROBOTO;
-  fontSize = 8;
-  fontBold = false;
-  fontItalic = false;
-  fontUnderlined?: DataCubeFontFormatUnderlinedVariant | undefined = undefined;
-  fontStrikethrough = false;
-  textAlign = DataCubeFontTextAlignment.LEFT;
-  foregroundColor = TailwindCSSPalette.black;
-  foregroundNegativeColor = DEFAULT_NEGATIVE_FOREGROUND_COLOR;
-  foregroundZeroColor = DEFAULT_ZERO_FOREGROUND_COLOR;
-  foregroundErrorColor = DEFAULT_ERROR_FOREGROUND_COLOR;
-  backgroundColor = DEFAULT_BACKGROUND_COLOR;
-  backgroundNegativeColor = DEFAULT_BACKGROUND_COLOR;
-  backgroundZeroColor = DEFAULT_BACKGROUND_COLOR;
-  backgroundErrorColor = DEFAULT_BACKGROUND_COLOR;
+  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;
 
   blur = false;
   hideFromView = false;
@@ -72,6 +88,10 @@ export class DataCubeColumnConfiguration {
   maxWidth?: number | undefined;
   pinned?: DataCubeColumnPinPlacement | undefined;
   displayAsLink = false;
+  linkLabelParameter?: string | undefined;
+
+  aggregateFunction?: DataCubeAggregateFunction | undefined;
+  excludedFromHorizontalPivot = false;
 
   constructor(name: string, type: string) {
     this.name = name;
@@ -80,35 +100,41 @@ export class DataCubeColumnConfiguration {
 
   static readonly serialization = new SerializationFactory(
     createModelSchema(DataCubeColumnConfiguration, {
-      backgroundColor: primitive(),
-      backgroundErrorColor: primitive(),
-      backgroundNegativeColor: primitive(),
-      backgroundZeroColor: primitive(),
+      aggregateFunction: optional(primitive()),
+      blur: primitive(),
       decimals: optional(primitive()),
       displayAsLink: primitive(),
       displayCommas: primitive(),
       displayName: optional(primitive()),
+      errorBackgroundColor: optional(primitive()),
+      errorForegroundColor: optional(primitive()),
+      excludedFromHorizontalPivot: primitive(),
       fixedWidth: optional(primitive()),
-      foregroundColor: primitive(),
-      foregroundErrorColor: primitive(),
-      foregroundNegativeColor: primitive(),
-      foregroundZeroColor: primitive(),
-      fontBold: primitive(),
-      fontFamily: primitive(),
-      fontItalic: primitive(),
-      fontSize: primitive(),
-      fontStrikethrough: primitive(),
-      fontUnderlined: 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(),
       hPivotSortFunction: optional(primitive()),
       kind: primitive(),
+      linkLabelParameter: optional(primitive()),
       maxWidth: optional(primitive()),
       minWidth: 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: primitive(),
+      textAlign: optional(primitive()),
       type: primitive(),
+      zeroBackgroundColor: optional(primitive()),
+      zeroForegroundColor: optional(primitive()),
     }),
   );
 }
@@ -117,45 +143,45 @@ export class DataCubeConfiguration {
   description?: string | undefined;
   columns: DataCubeColumnConfiguration[] = [];
 
-  showTreeLine = true;
-  showHorizontalGridLine = false;
-  showVerticalGridLine = false;
-  defaultFontFamily = DataCubeFont.ROBOTO;
-  defaultFontSize = 12;
-  defaultFontBold = false;
-  defaultFontItalic = false;
-  defaultFontUnderlined?: DataCubeFontFormatUnderlinedVariant | undefined =
-    undefined;
-  defaultFontStrikethrough = false;
-  defaultTextAlign = DataCubeFontTextAlignment.LEFT;
-  defaultForegroundColor = DEFAULT_FOREGROUND_COLOR;
-  defaultForegroundNegativeColor = DEFAULT_NEGATIVE_FOREGROUND_COLOR;
-  defaultForegroundZeroColor = DEFAULT_ZERO_FOREGROUND_COLOR;
-  defaultForegroundErrorColor = DEFAULT_ERROR_FOREGROUND_COLOR;
-  defaultBackgroundColor = DEFAULT_BACKGROUND_COLOR;
-  defaultBackgroundNegativeColor = DEFAULT_BACKGROUND_COLOR;
-  defaultBackgroundZeroColor = DEFAULT_BACKGROUND_COLOR;
-  defaultBackgroundErrorColor = DEFAULT_BACKGROUND_COLOR;
-  alternateRows = true;
+  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;
 
-  // manualRefresh: boolean;
-  numberScale?: DataCubeNumberScale | undefined;
-  selectionStats: DataCubeSelectionStat[] = [];
-
-  showWarningForTruncatedResult = true;
-
   // aggregation
   initialExpandLevel?: number | undefined;
   showRootAggregation = false;
-  showLeafCount = true;
+  showLeafCount = false;
   addPivotTotalColumn = true;
   addPivotTotalColumnOnLeft = true;
   treeGroupSortFunction?: string | undefined;
 
-  // advanced
-  rowBuffer = DEFAULT_ROW_BUFFER;
+  // misc
+  selectionStats: DataCubeSelectionStat[] = [];
+  showWarningForTruncatedResult = true;
 
   static readonly serialization = new SerializationFactory(
     createModelSchema(DataCubeConfiguration, {
@@ -164,37 +190,37 @@ export class DataCubeConfiguration {
       alternateRows: primitive(),
       alternateRowsColor: primitive(),
       alternateRowsCount: primitive(),
+      alternateRowsStandardMode: primitive(),
       columns: list(
         usingModelSchema(DataCubeColumnConfiguration.serialization.schema),
       ),
-      defaultBackgroundColor: primitive(),
-      defaultBackgroundErrorColor: primitive(),
-      defaultBackgroundNegativeColor: primitive(),
-      defaultBackgroundZeroColor: primitive(),
-      defaultFontBold: primitive(),
-      defaultFontFamily: primitive(),
-      defaultFontItalic: primitive(),
-      defaultFontSize: primitive(),
-      defaultFontStrikethrough: primitive(),
-      defaultFontUnderlined: optional(primitive()),
-      defaultForegroundColor: primitive(),
-      defaultForegroundErrorColor: primitive(),
-      defaultForegroundNegativeColor: primitive(),
-      defaultForegroundZeroColor: primitive(),
-      defaultTextAlign: primitive(),
+      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()),
-
-      numberScale: optional(primitive()),
-      rowBuffer: primitive(),
+      negativeBackgroundColor: primitive(),
+      negativeForegroundColor: primitive(),
+      normalBackgroundColor: primitive(),
+      normalForegroundColor: primitive(),
       selectionStats: list(primitive()),
-      showHorizontalGridLine: primitive(),
+      showHorizontalGridLines: primitive(),
       showLeafCount: primitive(),
       showRootAggregation: primitive(),
-      showTreeLine: primitive(),
-      showVerticalGridLine: primitive(),
+      showTreeLines: primitive(),
+      showVerticalGridLines: primitive(),
       showWarningForTruncatedResult: primitive(),
+      textAlign: primitive(),
       treeGroupSortFunction: optional(primitive()),
+      zeroBackgroundColor: primitive(),
+      zeroForegroundColor: primitive(),
     }),
   );
 }

package/src/stores/dataCube/core/DataCubeConfigurationBuilder.ts

@@ -19,7 +19,10 @@ import {
   DataCubeColumnConfiguration,
   DataCubeConfiguration,
 } from './DataCubeConfiguration.js';
-import { DataCubeColumnKind } from './DataCubeQueryEngine.js';
+import {
+  DataCubeColumnKind,
+  DataCubeFontTextAlignment,
+} from './DataCubeQueryEngine.js';
 
 export function buildDefaultColumnConfiguration(column: {
   name: string;
@@ -36,6 +39,7 @@ export function buildDefaultColumnConfiguration(column: {
       config.decimals = type === PRIMITIVE_TYPE.INTEGER ? 0 : 2;
       config.displayCommas = true;
       config.negativeNumberInParens = true;
+      config.textAlign = DataCubeFontTextAlignment.RIGHT; // always align number to the right
       break;
     }
     default: {

package/src/stores/dataCube/core/DataCubeCoreState.ts

@@ -40,7 +40,10 @@ export class DataCubeCoreState extends DataCubeQuerySnapshotSubscriber {
     this.name = val;
   }
 
-  override async applySnapshot(snapshot: DataCubeQuerySnapshot): Promise<void> {
+  override async applySnapshot(
+    snapshot: DataCubeQuerySnapshot,
+    previousSnapshot: DataCubeQuerySnapshot | undefined,
+  ): Promise<void> {
     const data = snapshot.data;
     this.setName(data.name);
     if (!this.startTime) {

package/src/stores/dataCube/core/DataCubeQueryBuilder.ts

@@ -51,9 +51,6 @@ import {
   type DataCubeQuerySnapshotFilterCondition,
   type DataCubeQuerySnapshotFilter,
   type DataCubeQuerySnapshot,
-  DataCubeQuerySnapshotSortOperation,
-  DataCubeQuerySnapshotFilterOperation,
-  DataCubeQueryFilterGroupOperation,
   _findCol,
   type DataCubeQuerySnapshotColumn,
   type DataCubeQuerySnapshotAggregateColumn,
@@ -71,6 +68,9 @@ import {
   DataCubeFunction,
   DEFAULT_LAMBDA_VARIABLE_NAME,
   INTERNAL__FILLER_COUNT_AGG_COLUMN_NAME,
+  DataCubeQuerySortOperation,
+  DataCubeQueryFilterOperation,
+  DataCubeQueryFilterGroupOperation,
   type DataCubeQueryFunctionMap,
 } from './DataCubeQueryEngine.js';
 
@@ -249,29 +249,29 @@ export function _filter(
     const _not = (fn: V1_AppliedFunction) =>
       _function(_name(DataCubeFunction.NOT), [fn]);
     switch (condition.operation) {
-      case DataCubeQuerySnapshotFilterOperation.EQUAL:
+      case DataCubeQueryFilterOperation.EQUAL:
         return _cond(DataCubeFunction.EQUAL, _val());
-      case DataCubeQuerySnapshotFilterOperation.GREATER_THAN:
+      case DataCubeQueryFilterOperation.GREATER_THAN:
         return _cond(DataCubeFunction.GREATER_THAN, _val());
-      case DataCubeQuerySnapshotFilterOperation.GREATER_THAN_OR_EQUAL:
+      case DataCubeQueryFilterOperation.GREATER_THAN_OR_EQUAL:
         return _cond(DataCubeFunction.GREATER_THAN_EQUAL, _val());
-      case DataCubeQuerySnapshotFilterOperation.LESS_THAN:
+      case DataCubeQueryFilterOperation.LESS_THAN:
         return _cond(DataCubeFunction.LESS_THAN, _val());
-      case DataCubeQuerySnapshotFilterOperation.LESS_THAN_OR_EQUAL:
+      case DataCubeQueryFilterOperation.LESS_THAN_OR_EQUAL:
         return _cond(DataCubeFunction.LESS_THAN_EQUAL, _val());
-      case DataCubeQuerySnapshotFilterOperation.CONTAINS:
+      case DataCubeQueryFilterOperation.CONTAINS:
         return _cond(DataCubeFunction.CONTAINS, _val());
-      case DataCubeQuerySnapshotFilterOperation.ENDS_WITH:
+      case DataCubeQueryFilterOperation.ENDS_WITH:
         return _cond(DataCubeFunction.ENDS_WITH, _val());
-      case DataCubeQuerySnapshotFilterOperation.STARTS_WITH:
+      case DataCubeQueryFilterOperation.STARTS_WITH:
         return _cond(DataCubeFunction.STARTS_WITH, _val());
-      case DataCubeQuerySnapshotFilterOperation.BLANK:
+      case DataCubeQueryFilterOperation.BLANK:
         return _cond(DataCubeFunction.IS_EMPTY);
-      case DataCubeQuerySnapshotFilterOperation.NOT_EQUAL:
+      case DataCubeQueryFilterOperation.NOT_EQUAL:
         return _not(_cond(DataCubeFunction.EQUAL, _val()));
-      case DataCubeQuerySnapshotFilterOperation.NOT_BLANK:
+      case DataCubeQueryFilterOperation.NOT_BLANK:
         return _not(_cond(DataCubeFunction.IS_EMPTY));
-      case DataCubeQuerySnapshotFilterOperation.NOT_CONTAINS:
+      case DataCubeQueryFilterOperation.NOT_CONTAINS:
         return _not(_cond(DataCubeFunction.CONTAINS, _val()));
       default:
         throw new UnsupportedOperationError(
@@ -332,6 +332,17 @@ export function buildExecutableQuery(
     funcMap[funcMapKey] = func;
   };
 
+  // --------------------------------- FILTER ---------------------------------
+
+  if (data.filter) {
+    _process(
+      'filter',
+      _function(_name(DataCubeFunction.FILTER), [
+        _lambda([_var()], [_filter(data.filter)]),
+      ]),
+    );
+  }
+
   // --------------------------------- LEAF EXTEND ---------------------------------
 
   if (data.leafExtendedColumns.length) {
@@ -358,17 +369,6 @@ export function buildExecutableQuery(
     );
   }
 
-  // --------------------------------- FILTER ---------------------------------
-
-  if (data.filter) {
-    _process(
-      'filter',
-      _function(_name(DataCubeFunction.FILTER), [
-        _lambda([_var()], [_filter(data.filter)]),
-      ]),
-    );
-  }
-
   // --------------------------------- GROUP BY ---------------------------------
 
   if (data.groupBy) {
@@ -419,7 +419,7 @@ export function buildExecutableQuery(
           data.sortColumns.map((col) =>
             _function(
               _name(
-                col.operation === DataCubeQuerySnapshotSortOperation.ASCENDING
+                col.operation === DataCubeQuerySortOperation.ASCENDING
                   ? DataCubeFunction.ASC
                   : DataCubeFunction.DESC,
               ),