@finos/legend-application-repl 0.0.53 → 0.0.55

package/src/stores/REPLStore.tsx

@@ -31,7 +31,7 @@ import {
   DEFAULT_SMALL_ALERT_WINDOW_CONFIG,
   LayoutConfiguration,
   LayoutManagerState,
-  SingletonModeDisplayState,
+  DisplayState,
   WindowState,
   type WindowConfiguration,
 } from './LayoutManagerState.js';
@@ -48,8 +48,8 @@ export class REPLStore {
   readonly client: REPLServerClient;
   readonly layout: LayoutManagerState;
   readonly initState = ActionState.create();
-  readonly settingsDisplay: SingletonModeDisplayState;
-  readonly documentationDisplay: SingletonModeDisplayState;
+  readonly settingsDisplay: DisplayState;
+  readonly documentationDisplay: DisplayState;
 
   dataCubeEngine!: DataCubeEngine;
 
@@ -73,11 +73,9 @@ export class REPLStore {
     this.layout = new LayoutManagerState(this.application);
     this.dataCubeEngine = new DataCubeEngine(this);
     this.dataCube = new DataCubeState(this);
-    this.settingsDisplay = new SingletonModeDisplayState(
-      this.layout,
-      'Settings',
-      () => <SettingsPanel />,
-    );
+    this.settingsDisplay = new DisplayState(this.layout, 'Settings', () => (
+      <SettingsPanel />
+    ));
     this.settingsDisplay.configuration.window = {
       x: -50,
       y: 50,
@@ -87,7 +85,7 @@ export class REPLStore {
       minHeight: 200,
       center: false,
     };
-    this.documentationDisplay = new SingletonModeDisplayState(
+    this.documentationDisplay = new DisplayState(
       this.layout,
       'Documentation',
       () => <DocumentationPanel />,
@@ -181,7 +179,7 @@ export class REPLStore {
     } catch (error: unknown) {
       assertErrorThrown(error);
       this.application.alertService.setActionAlertInfo({
-        message: `Initialization failure: ${error.message}`,
+        message: `Initialization Failure: ${error.message}`,
         prompt: `Resolve the issue and reload the application.`,
         type: ActionAlertType.ERROR,
         actions: [],

package/src/stores/dataCube/DataCubeEngine.ts

@@ -28,8 +28,9 @@ import {
   DataCubeGetBaseQueryResult,
   type DataCubeInfrastructureInfo,
   type CompletionItem,
+  type RelationType,
 } from '../../server/REPLEngine.js';
-import { guaranteeNonNullable, guaranteeType } from '@finos/legend-shared';
+import { guaranteeType } from '@finos/legend-shared';
 import type { LegendREPLApplicationStore } from '../LegendREPLBaseStore.js';
 import type { REPLStore } from '../REPLStore.js';
 import { action, makeObservable, observable } from 'mobx';
@@ -60,7 +61,21 @@ import { DataCubeQueryFilterOperation__EndWithCaseInsensitive } from './core/fil
 import { DataCubeQueryFilterOperation__NotEndWith } from './core/filter/DataCubeQueryFilterOperation__NotEndWith.js';
 import { DataCubeQueryFilterOperation__IsNull } from './core/filter/DataCubeQueryFilterOperation__IsNull.js';
 import { DataCubeQueryFilterOperation__IsNotNull } from './core/filter/DataCubeQueryFilterOperation__IsNotNull.js';
-import type { DataCubeQueryFilterOperation } from './core/filter/DataCubeQueryFilterOperation.js';
+import { getFilterOperation } from './core/filter/DataCubeQueryFilterOperation.js';
+import { DataCubeQueryAggregateOperation__Sum } from './core/aggregation/DataCubeQueryAggregateOperation__Sum.js';
+import { DataCubeQueryAggregateOperation__Average } from './core/aggregation/DataCubeQueryAggregateOperation__Average.js';
+import { DataCubeQueryAggregateOperation__Count } from './core/aggregation/DataCubeQueryAggregateOperation__Count.js';
+import { DataCubeQueryAggregateOperation__Min } from './core/aggregation/DataCubeQueryAggregateOperation__Min.js';
+import { DataCubeQueryAggregateOperation__Max } from './core/aggregation/DataCubeQueryAggregateOperation__Max.js';
+import { DataCubeQueryAggregateOperation__UniqueValue } from './core/aggregation/DataCubeQueryAggregateOperation__UniqueValue.js';
+import { DataCubeQueryAggregateOperation__First } from './core/aggregation/DataCubeQueryAggregateOperation__First.js';
+import { DataCubeQueryAggregateOperation__Last } from './core/aggregation/DataCubeQueryAggregateOperation__Last.js';
+import { DataCubeQueryAggregateOperation__VariancePopulation } from './core/aggregation/DataCubeQueryAggregateOperation__VariancePopulation.js';
+import { DataCubeQueryAggregateOperation__VarianceSample } from './core/aggregation/DataCubeQueryAggregateOperation__VarianceSample.js';
+import { DataCubeQueryAggregateOperation__StdDevPopulation } from './core/aggregation/DataCubeQueryAggregateOperation__StdDevPopulation.js';
+import { DataCubeQueryAggregateOperation__StdDevSample } from './core/aggregation/DataCubeQueryAggregateOperation__StdDevSample.js';
+import { DataCubeQueryAggregateOperation__JoinStrings } from './core/aggregation/DataCubeQueryAggregateOperation__JoinStrings.js';
+import { getAggregateOperation } from './core/aggregation/DataCubeQueryAggregateOperation.js';
 
 export const DEFAULT_ENABLE_DEBUG_MODE = false;
 export const DEFAULT_GRID_CLIENT_ROW_BUFFER = 50;
@@ -105,6 +120,22 @@ export class DataCubeEngine {
     new DataCubeQueryFilterOperation__GreaterThanOrEqualColumn(),
   ];
 
+  readonly aggregateOperations = [
+    new DataCubeQueryAggregateOperation__Sum(),
+    new DataCubeQueryAggregateOperation__Average(),
+    new DataCubeQueryAggregateOperation__Count(),
+    new DataCubeQueryAggregateOperation__Min(),
+    new DataCubeQueryAggregateOperation__Max(),
+    new DataCubeQueryAggregateOperation__UniqueValue(),
+    new DataCubeQueryAggregateOperation__First(),
+    new DataCubeQueryAggregateOperation__Last(),
+    new DataCubeQueryAggregateOperation__VariancePopulation(),
+    new DataCubeQueryAggregateOperation__VarianceSample(),
+    new DataCubeQueryAggregateOperation__StdDevPopulation(),
+    new DataCubeQueryAggregateOperation__StdDevSample(),
+    new DataCubeQueryAggregateOperation__JoinStrings(),
+  ];
+
   enableDebugMode = DEFAULT_ENABLE_DEBUG_MODE;
   gridClientRowBuffer = DEFAULT_GRID_CLIENT_ROW_BUFFER;
   gridClientPurgeClosedRowNodes = DEFAULT_GRID_CLIENT_PURGE_CLOSED_ROW_NODES;
@@ -130,11 +161,12 @@ export class DataCubeEngine {
     this.client = repl.client;
   }
 
-  getFilterOperation(operator: string): DataCubeQueryFilterOperation {
-    return guaranteeNonNullable(
-      this.filterOperations.find((op) => op.operator === operator),
-      `Can't find filter operation '${operator}'`,
-    );
+  getFilterOperation(operator: string) {
+    return getFilterOperation(operator, this.filterOperations);
+  }
+
+  getAggregateOperation(operator: string) {
+    return getAggregateOperation(operator, this.aggregateOperations);
   }
 
   setEnableDebugMode(enableDebugMode: boolean) {
@@ -176,11 +208,11 @@ export class DataCubeEngine {
 
   async getQueryTypeahead(
     code: string,
-    isPartial?: boolean,
+    query: V1_ValueSpecification,
   ): Promise<CompletionItem[]> {
     return (await this.client.getQueryTypeahead({
       code,
-      isPartial,
+      baseQuery: V1_serializeValueSpecification(query, []),
     })) as CompletionItem[];
   }
 
@@ -200,6 +232,24 @@ export class DataCubeEngine {
     );
   }
 
+  async getQueryRelationType(
+    query: V1_ValueSpecification,
+  ): Promise<RelationType> {
+    return this.client.getQueryRelationReturnType({
+      query: V1_serializeValueSpecification(query, []),
+    });
+  }
+
+  async getQueryCodeRelationReturnType(
+    code: string,
+    query: V1_ValueSpecification,
+  ): Promise<RelationType> {
+    return this.client.getQueryCodeRelationReturnType({
+      code,
+      baseQuery: V1_serializeValueSpecification(query, []),
+    });
+  }
+
   async executeQuery(query: V1_Lambda): Promise<{
     result: TDSExecutionResult;
     executedQuery: string;

package/src/stores/dataCube/DataCubeState.ts

@@ -20,14 +20,15 @@ import { DataCubeEditorState } from './editor/DataCubeEditorState.js';
 import { assertErrorThrown, uuid } from '@finos/legend-shared';
 import { DataCubeQuerySnapshotManager } from './core/DataCubeQuerySnapshotManager.js';
 import type { LegendREPLApplicationStore } from '../LegendREPLBaseStore.js';
-import { DataCubeStaticContentDisplayState } from './core/DataCubeStaticContentDisplayState.js';
+import { DataCubeInfoState } from './core/DataCubeInfoState.js';
 import { validateAndBuildQuerySnapshot } from './core/DataCubeQuerySnapshotBuilder.js';
 import { action, makeObservable, observable } from 'mobx';
 import type { DataCubeEngine } from './DataCubeEngine.js';
 import { ActionAlertType } from '@finos/legend-application';
 import { DataCubeFilterEditorState } from './filter/DataCubeFilterEditorState.js';
+import { DataCubeExtendManagerState } from './extend/DataCubeExtendManagerState.js';
 
-export class DataCubeTask {
+class DataCubeTask {
   uuid = uuid();
   name: string;
   startTime = Date.now();
@@ -48,10 +49,11 @@ export class DataCubeState {
   readonly engine: DataCubeEngine;
   readonly snapshotManager: DataCubeQuerySnapshotManager;
 
-  readonly staticContent: DataCubeStaticContentDisplayState;
-  readonly grid: DataCubeGridState;
+  readonly info: DataCubeInfoState;
   readonly editor: DataCubeEditorState;
+  readonly grid: DataCubeGridState;
   readonly filter: DataCubeFilterEditorState;
+  readonly extend: DataCubeExtendManagerState;
 
   readonly runningTasks = new Map<string, DataCubeTask>();
 
@@ -68,10 +70,12 @@ export class DataCubeState {
 
     // NOTE: snapshot manager must be instantiated before subscribers
     this.snapshotManager = new DataCubeQuerySnapshotManager(this);
-    this.staticContent = new DataCubeStaticContentDisplayState(this);
+
+    this.info = new DataCubeInfoState(this);
     this.editor = new DataCubeEditorState(this);
-    this.filter = new DataCubeFilterEditorState(this);
     this.grid = new DataCubeGridState(this);
+    this.filter = new DataCubeFilterEditorState(this);
+    this.extend = new DataCubeExtendManagerState(this);
   }
 
   newTask(name: string) {
@@ -91,12 +95,12 @@ export class DataCubeState {
     try {
       await Promise.all(
         [
-          this.staticContent,
+          this.info,
           this.editor,
           this.grid,
           this.grid.controller,
           this.filter,
-          // TODO this.editor.extendedColumns,
+          this.extend,
         ].map(async (state) => {
           this.snapshotManager.registerSubscriber(state);
         }),
@@ -112,7 +116,7 @@ export class DataCubeState {
     } catch (error: unknown) {
       assertErrorThrown(error);
       this.repl.application.alertService.setActionAlertInfo({
-        message: `Initialization failure: ${error.message}`,
+        message: `Initialization Failure: ${error.message}`,
         prompt: `Resolve the issue and reload the application.`,
         type: ActionAlertType.ERROR,
         actions: [],

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

@@ -38,9 +38,10 @@ import {
   type DataCubeSelectionStat,
   type DataCubeColumnPinPlacement,
   type DataCubeFontCase,
+  type DataCubeOperationValue,
 } from './DataCubeQueryEngine.js';
 import { SerializationFactory, usingModelSchema } from '@finos/legend-shared';
-import { createModelSchema, list, optional, primitive } from 'serializr';
+import { createModelSchema, list, optional, primitive, raw } from 'serializr';
 
 export type DataCubeConfigurationColorKey =
   | 'normal'
@@ -89,6 +90,11 @@ export class DataCubeColumnConfiguration {
   displayAsLink = false;
   linkLabelParameter?: string | undefined;
 
+  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;
@@ -96,6 +102,8 @@ export class DataCubeColumnConfiguration {
 
   static readonly serialization = new SerializationFactory(
     createModelSchema(DataCubeColumnConfiguration, {
+      aggregateOperator: primitive(),
+      aggregationParameters: list(raw()),
       blur: primitive(),
       decimals: optional(primitive()),
       displayAsLink: primitive(),
@@ -103,6 +111,7 @@ export class DataCubeColumnConfiguration {
       displayName: optional(primitive()),
       errorBackgroundColor: optional(primitive()),
       errorForegroundColor: optional(primitive()),
+      excludedFromHorizontalPivot: primitive(),
       fixedWidth: optional(primitive()),
       fontBold: optional(primitive()),
       fontCase: optional(primitive()),
@@ -112,6 +121,7 @@ export class DataCubeColumnConfiguration {
       fontStrikethrough: optional(primitive()),
       fontUnderline: optional(primitive()),
       hideFromView: primitive(),
+      horizontalPivotSortFunction: optional(primitive()),
       kind: primitive(),
       linkLabelParameter: optional(primitive()),
       maxWidth: optional(primitive()),

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

@@ -20,6 +20,7 @@ import {
   DataCubeConfiguration,
 } from './DataCubeConfiguration.js';
 import {
+  DataCubeAggregateOperator,
   DataCubeColumnKind,
   DataCubeFontTextAlignment,
 } from './DataCubeQueryEngine.js';
@@ -40,9 +41,14 @@ export function buildDefaultColumnConfiguration(column: {
       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;
     }
   }

package/src/stores/dataCube/core/{DataCubeStaticContentDisplayState.ts → DataCubeInfoState.ts}

@@ -22,21 +22,26 @@ import type { DataCubeQuery } from '../../../server/DataCubeQuery.js';
 import { formatDate } from '@finos/legend-shared';
 import { DEFAULT_REPORT_NAME } from './DataCubeQueryEngine.js';
 
-export class DataCubeStaticContentDisplayState extends DataCubeQuerySnapshotController {
+/**
+ * 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 startTime?: number | undefined;
+  private editionStartTime?: number | undefined;
 
   constructor(dataCube: DataCubeState) {
     super(dataCube);
 
-    makeObservable(this, {
+    makeObservable<DataCubeInfoState, 'setName'>(this, {
       name: observable,
       setName: action,
     });
   }
 
-  setName(val: string) {
+  private setName(val: string) {
     this.name = val;
   }
 
@@ -46,11 +51,11 @@ export class DataCubeStaticContentDisplayState extends DataCubeQuerySnapshotCont
   ) {
     const data = snapshot.data;
     this.setName(data.name);
-    if (!this.startTime) {
-      this.startTime = snapshot.timestamp;
+    if (!this.editionStartTime) {
+      this.editionStartTime = snapshot.timestamp;
     }
     this.application.layoutService.setWindowTitle(
-      `\u229E ${data.name}${this.startTime ? ` - ${formatDate(new Date(this.startTime), 'HH:mm:ss EEE MMM dd yyyy')}` : ''}`,
+      `\u229E ${data.name}${this.editionStartTime ? ` - ${formatDate(new Date(this.editionStartTime), 'HH:mm:ss EEE MMM dd yyyy')}` : ''}`,
     );
   }
 }

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

@@ -27,9 +27,17 @@ import {
   V1_deserializeValueSpecification,
   extractElementNameFromPath as _name,
 } from '@finos/legend-graph';
-import { type DataCubeQuerySnapshot } from './DataCubeQuerySnapshot.js';
-import { guaranteeNonNullable } from '@finos/legend-shared';
 import {
+  type DataCubeQuerySnapshot,
+  type DataCubeQuerySnapshotSimpleExtendedColumn,
+} from './DataCubeQuerySnapshot.js';
+import {
+  guaranteeNonNullable,
+  isNonNullable,
+  UnsupportedOperationError,
+} from '@finos/legend-shared';
+import {
+  DataCubeExtendedColumnType,
   DataCubeFunction,
   DataCubeQuerySortOperator,
   type DataCubeQueryFunctionMap,
@@ -46,15 +54,16 @@ import {
   _filter,
   _function,
   _groupByAggCols,
-  _groupByExtend,
   _lambda,
   _primitiveValue,
   _var,
 } from './DataCubeQueryBuilderUtils.js';
+import type { DataCubeQueryAggregateOperation } from './aggregation/DataCubeQueryAggregateOperation.js';
 
 export function buildExecutableQuery(
   snapshot: DataCubeQuerySnapshot,
   filterOperations: DataCubeQueryFilterOperation[],
+  aggregateOperations: DataCubeQueryAggregateOperation[],
   options?: {
     postProcessor?: (
       snapshot: DataCubeQuerySnapshot,
@@ -62,6 +71,7 @@ export function buildExecutableQuery(
       funcMap: DataCubeQueryFunctionMap,
       configuration: DataCubeConfiguration,
       filterOperations: DataCubeQueryFilterOperation[],
+      aggregateOperations: DataCubeQueryAggregateOperation[],
     ) => void;
     pagination?:
       | {
@@ -86,16 +96,22 @@ export function buildExecutableQuery(
     funcMap[funcMapKey] = func;
   };
 
-  // --------------------------------- LEAF EXTEND ---------------------------------
+  // --------------------------------- LEAF-LEVEL EXTEND ---------------------------------
 
   if (data.leafExtendedColumns.length) {
     _process(
       'leafExtend',
       _function(_name(DataCubeFunction.EXTEND), [
         _cols(
-          data.leafExtendedColumns.map((col) =>
-            _colSpec(col.name, _deserializeToLambda(col.lambda)),
-          ),
+          data.leafExtendedColumns.map((eCol) => {
+            if (eCol._type === DataCubeExtendedColumnType.SIMPLE) {
+              const col = eCol as DataCubeQuerySnapshotSimpleExtendedColumn;
+              return _colSpec(col.name, _deserializeToLambda(col.lambda));
+            }
+            throw new UnsupportedOperationError(
+              `Can't build extended column of type '${eCol._type}'`,
+            );
+          }),
         ),
       ]),
     );
@@ -131,33 +147,37 @@ export function buildExecutableQuery(
       'groupBy',
       _function(_name(DataCubeFunction.GROUP_BY), [
         _cols(groupBy.columns.map((col) => _colSpec(col.name))),
-        _cols(_groupByAggCols(groupBy.aggColumns)),
+        _cols(
+          _groupByAggCols(
+            groupBy.columns,
+            snapshot,
+            configuration,
+            aggregateOperations,
+          ),
+        ),
       ]),
     );
-
-    // extend columns to maintain the same set of columns prior to groupBy()
-    const groupByExtend = _groupByExtend(snapshot.stageCols('aggregation'), [
-      ...groupBy.columns,
-      ...groupBy.aggColumns,
-    ]);
-    if (groupByExtend) {
-      _process('groupByExtend', groupByExtend);
-    }
   }
 
   // --------------------------------- PIVOT ---------------------------------
-  // TODO: @akphi - implement this and CAST
+  /** TODO: @datacube pivot - implement this and CAST */
 
-  // --------------------------------- GROUP EXTEND ---------------------------------
+  // --------------------------------- GROUP-LEVEL EXTEND ---------------------------------
 
   if (data.groupExtendedColumns.length) {
     _process(
       'groupExtend',
       _function(_name(DataCubeFunction.EXTEND), [
         _cols(
-          data.groupExtendedColumns.map((col) =>
-            _colSpec(col.name, _deserializeToLambda(col.lambda)),
-          ),
+          data.groupExtendedColumns.map((eCol) => {
+            if (eCol._type === DataCubeExtendedColumnType.SIMPLE) {
+              const col = eCol as DataCubeQuerySnapshotSimpleExtendedColumn;
+              return _colSpec(col.name, _deserializeToLambda(col.lambda));
+            }
+            throw new UnsupportedOperationError(
+              `Can't build extended column of type '${eCol._type}'`,
+            );
+          }),
         ),
       ]),
     );
@@ -210,7 +230,13 @@ export function buildExecutableQuery(
   // --------------------------------- FROM ---------------------------------
 
   sequence.push(
-    _function(_name(DataCubeFunction.FROM), [_elementPtr(data.runtime)]),
+    _function(
+      _name(DataCubeFunction.FROM),
+      [
+        data.mapping ? _elementPtr(data.mapping) : undefined,
+        _elementPtr(data.runtime),
+      ].filter(isNonNullable),
+    ),
   );
 
   // --------------------------------- FINALIZE ---------------------------------
@@ -221,6 +247,7 @@ export function buildExecutableQuery(
     funcMap,
     configuration,
     filterOperations,
+    aggregateOperations,
   );
 
   if (!sequence.length) {