@finos/legend-application-repl 0.0.52 → 0.0.54

package/src/components/repl/PureCodeEditor.tsx

@@ -0,0 +1,91 @@
+/**
+ * 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 editor as monacoEditorAPI,
+  languages as monacoLanguagesAPI,
+  type IPosition,
+} from 'monaco-editor';
+import type { DataCubeState } from '../../stores/dataCube/DataCubeState.js';
+import type { CompletionItem } from '../../server/REPLEngine.js';
+import type { V1_ValueSpecification } from '@finos/legend-graph';
+
+// Since we render the editor in a window which has been CSS transformed, and monaco-editor renders
+// the widgets with position=fixed, the position of the widgets will be off, we need to move the root
+// which monaco-editor uses to calculate the offset to outside of the transformed container
+// See https://dev.to/salilnaik/the-uncanny-relationship-between-position-fixed-and-transform-property-32f6
+// See https://github.com/microsoft/monaco-editor/issues/2793#issuecomment-999337740
+export const MONACO_EDITOR_OVERFLOW_WIDGETS_ROOT_ID =
+  'monaco-editor-overflow-widgets-root';
+export function INTERNAL__MonacoEditorWidgetsRoot() {
+  return (
+    <div
+      id={MONACO_EDITOR_OVERFLOW_WIDGETS_ROOT_ID}
+      className="monaco-editor" // keep this root class so widgets can be styled properly
+    />
+  );
+}
+
+export async function getCodeSuggestions(
+  position: IPosition,
+  model: monacoEditorAPI.ITextModel,
+  prefix: string | undefined,
+  dataCube: DataCubeState,
+  baseQueryBuilder: () => V1_ValueSpecification,
+) {
+  const textUntilPosition = model.getValueInRange({
+    startLineNumber: 1,
+    startColumn: 1,
+    endLineNumber: position.lineNumber,
+    endColumn: position.column,
+  });
+  const currentWord = model.getWordAtPosition(position);
+
+  let suggestions: CompletionItem[] = [];
+
+  try {
+    suggestions = await dataCube.engine.getQueryTypeahead(
+      (prefix ?? '') + textUntilPosition,
+      baseQueryBuilder(),
+    );
+  } catch {
+    // do nothing: provide no suggestions when error ocurred
+  }
+  return suggestions.map(
+    (suggestion) =>
+      ({
+        label: suggestion.display,
+        kind: monacoLanguagesAPI.CompletionItemKind.Text, // TODO: we need REPL to provide this information
+        filterText: suggestion.display,
+        insertTextRules:
+          monacoLanguagesAPI.CompletionItemInsertTextRule.InsertAsSnippet,
+        insertText: suggestion.completion,
+        // NOTE: the following replace range is equivalent to the current word range, if there is a current word,
+        // replace this word with the suggestions, otherwise, if there is no current word, we use the current position
+        // as insertion point for the suggestion. This is due to the fact that the auto-completer gives full word
+        // suggestions even when the user is typing the middle of that word
+        //
+        // For example, if the current input is 'a' and the suggestion is 'abc', we need to make sure
+        // the suggestion is inserted so that the final result is 'abc', not 'aabc'
+        range: {
+          startLineNumber: position.lineNumber,
+          startColumn: currentWord?.startColumn ?? position.column,
+          endLineNumber: position.lineNumber,
+          endColumn: currentWord?.endColumn ?? position.column,
+        },
+      }) as monacoLanguagesAPI.CompletionItem,
+  );
+}

package/src/server/REPLEngine.ts

@@ -14,41 +14,39 @@
  * limitations under the License.
  */
 
-import { createModelSchema, custom, optional, primitive } from 'serializr';
-import { SerializationFactory, usingModelSchema } from '@finos/legend-shared';
+import { createModelSchema, custom, primitive } from 'serializr';
+import {
+  SerializationFactory,
+  usingModelSchema,
+  type PlainObject,
+} from '@finos/legend-shared';
 import {
   type V1_ValueSpecification,
   type V1_Lambda,
   V1_deserializeValueSpecification,
   V1_serializeValueSpecification,
-  V1_lambdaModelSchema,
 } from '@finos/legend-graph';
 import { DataCubeQuery, type DataCubeQueryColumn } from './DataCubeQuery.js';
 
-export class DataCubeInfrastructureInfo {
-  gridClientLicense?: string | undefined;
+export type DataCubeQueryBuilderError = {
+  type: string;
+  message: string;
+  sourceInformation?: {
+    startLine: number;
+    startColumn: number;
+    endLine: number;
+    endColumn: number;
+  };
+};
 
-  static readonly serialization = new SerializationFactory(
-    createModelSchema(DataCubeInfrastructureInfo, {
-      gridClientLicense: optional(primitive()),
-    }),
-  );
-}
+export type DataCubeInfrastructureInfo = {
+  gridClientLicense?: string | undefined;
+};
 
-export class DataCubeGetQueryCodeInput {
-  query!: V1_ValueSpecification; // TODO: @akphi - consider if we should update this to use Lambda instead
+export type DataCubeGetQueryCodeInput = {
+  query: PlainObject<V1_ValueSpecification>; // TODO: @akphi - consider if we should update this to use Lambda instead
   pretty?: boolean;
-
-  static readonly serialization = new SerializationFactory(
-    createModelSchema(DataCubeGetQueryCodeInput, {
-      pretty: optional(primitive()),
-      query: custom(
-        (val) => V1_serializeValueSpecification(val, []),
-        (val) => V1_deserializeValueSpecification(val, []),
-      ),
-    }),
-  );
-}
+};
 
 export type DataCubeParseQueryInput = {
   code: string;
@@ -62,30 +60,22 @@ export type CompletionItem = {
 
 export type DataCubeQueryTypeaheadInput = {
   code: string;
-  isPartial?: boolean | undefined;
+  baseQuery?: PlainObject<V1_ValueSpecification>;
 };
 
-export class DataCubeGetQueryRelationReturnTypeInput {
-  query!: V1_Lambda;
+export type DataCubeGetQueryRelationReturnTypeInput = {
+  query: PlainObject<V1_Lambda>;
+};
 
-  static readonly serialization = new SerializationFactory(
-    createModelSchema(DataCubeGetQueryRelationReturnTypeInput, {
-      query: usingModelSchema(V1_lambdaModelSchema([])),
-    }),
-  );
-}
+export type DataCubeGetQueryCodeRelationReturnTypeInput = {
+  code: string;
+  baseQuery?: PlainObject<V1_ValueSpecification>;
+};
 
-export class DataCubeExecutionInput {
-  query!: V1_Lambda;
+export type DataCubeExecutionInput = {
+  query: PlainObject<V1_Lambda>;
   debug?: boolean | undefined;
-
-  static readonly serialization = new SerializationFactory(
-    createModelSchema(DataCubeExecutionInput, {
-      debug: optional(primitive()),
-      query: usingModelSchema(V1_lambdaModelSchema([])),
-    }),
-  );
-}
+};
 
 export type DataCubeExecutionResult = {
   result: string;

package/src/server/REPLServerClient.ts

@@ -30,6 +30,7 @@ import type {
   DataCubeExecutionResult,
   DataCubeGetBaseQueryResult,
   DataCubeInfrastructureInfo,
+  DataCubeGetQueryCodeRelationReturnTypeInput,
 } from './REPLEngine.js';
 import type { V1_ValueSpecification } from '@finos/legend-graph';
 
@@ -77,7 +78,7 @@ export class REPLServerClient {
     return this.networkClient.get(`${this.dataCube}/getBaseQuery`);
   }
 
-  async getRelationReturnType(
+  async getQueryRelationReturnType(
     input: DataCubeGetQueryRelationReturnTypeInput,
   ): Promise<RelationType> {
     return this.networkClient.post(
@@ -86,6 +87,15 @@ export class REPLServerClient {
     );
   }
 
+  async getQueryCodeRelationReturnType(
+    input: DataCubeGetQueryCodeRelationReturnTypeInput,
+  ): Promise<RelationType> {
+    return this.networkClient.post(
+      `${this.dataCube}/getRelationReturnType/code`,
+      input,
+    );
+  }
+
   async executeQuery(
     input: PlainObject<DataCubeExecutionInput>,
   ): Promise<DataCubeExecutionResult> {

package/src/stores/LayoutManagerState.ts

@@ -114,7 +114,7 @@ export const DEFAULT_TOOL_PANEL_WINDOW_CONFIG: WindowConfiguration = {
 
 export const DEFAULT_SMALL_ALERT_WINDOW_CONFIG: WindowConfiguration = {
   width: 500,
-  height: 80,
+  height: 200,
   minWidth: 200,
   minHeight: 80,
   center: true,
@@ -128,7 +128,7 @@ export const DEFAULT_LARGE_ALERT_WINDOW_CONFIG: WindowConfiguration = {
   center: true,
 };
 
-export class SingletonModeDisplayState {
+export class DisplayState {
   readonly layoutManagerState: LayoutManagerState;
   readonly configuration: LayoutConfiguration;
   window?: WindowState | undefined;

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,6 +28,7 @@ import {
   DataCubeGetBaseQueryResult,
   type DataCubeInfrastructureInfo,
   type CompletionItem,
+  type RelationType,
 } from '../../server/REPLEngine.js';
 import { guaranteeNonNullable, guaranteeType } from '@finos/legend-shared';
 import type { LegendREPLApplicationStore } from '../LegendREPLBaseStore.js';
@@ -176,11 +177,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 +201,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/{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,16 @@ 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,
+  UnsupportedOperationError,
+} from '@finos/legend-shared';
+import {
+  DataCubeExtendedColumnType,
   DataCubeFunction,
   DataCubeQuerySortOperator,
   type DataCubeQueryFunctionMap,
@@ -86,16 +93,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}'`,
+            );
+          }),
         ),
       ]),
     );
@@ -148,16 +161,22 @@ export function buildExecutableQuery(
   // --------------------------------- PIVOT ---------------------------------
   // TODO: @akphi - 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}'`,
+            );
+          }),
         ),
       ]),
     );

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

@@ -252,10 +252,17 @@ export enum DataCubeColumnPinPlacement {
   RIGHT = 'Right',
 }
 
+// TODO: support moreclassifications of this column, it can also be aggregation with map/reduce or
+// OLAP window aggregation, or custom groupings, etc.
+export enum DataCubeExtendedColumnType {
+  SIMPLE = 'simple',
+}
+
 export enum DataCubeColumnDataType {
-  NUMBER = 'number',
-  DATE = 'date',
-  TEXT = 'text',
+  NUMBER = 'Numeric',
+  TEXT = 'Text',
+  DATE = 'Date',
+  TIME = 'Time',
 }
 
 export function getDataType(type: string): DataCubeColumnDataType {
@@ -266,15 +273,23 @@ export function getDataType(type: string): DataCubeColumnDataType {
     case PRIMITIVE_TYPE.FLOAT:
       return DataCubeColumnDataType.NUMBER;
     case PRIMITIVE_TYPE.DATE:
-    case PRIMITIVE_TYPE.DATETIME:
     case PRIMITIVE_TYPE.STRICTDATE:
       return DataCubeColumnDataType.DATE;
+    case PRIMITIVE_TYPE.DATETIME:
+      return DataCubeColumnDataType.TIME;
     case PRIMITIVE_TYPE.STRING:
     default:
       return DataCubeColumnDataType.TEXT;
   }
 }
 
+export function ofDataType(
+  type: string,
+  dataTypes: DataCubeColumnDataType[],
+): boolean {
+  return dataTypes.includes(getDataType(type));
+}
+
 export const DEFAULT_URL_LABEL_QUERY_PARAM = 'dataCube.linkLabel';
 export const DEFAULT_MISSING_VALUE_DISPLAY_TEXT = '';
 

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

@@ -50,8 +50,12 @@ export type DataCubeQuerySnapshotColumn = {
 
 export type DataCubeQuerySnapshotExtendedColumn =
   DataCubeQuerySnapshotColumn & {
+    _type: string;
+  };
+
+export type DataCubeQuerySnapshotSimpleExtendedColumn =
+  DataCubeQuerySnapshotExtendedColumn & {
     lambda: PlainObject<V1_Lambda>;
-    code: string;
   };
 
 export type DataCubeQuerySnapshotSortColumn = DataCubeQuerySnapshotColumn & {

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

@@ -294,7 +294,7 @@ export function validateAndBuildQuerySnapshot(
   }));
   data.sourceColumns.map((col) => colsMap.set(col.name, col));
 
-  // --------------------------------- LEAF EXTEND ---------------------------------
+  // --------------------------------- LEAF-LEVEL EXTEND ---------------------------------
   // TODO: @akphi - implement this
 
   // --------------------------------- FILTER ---------------------------------
@@ -327,7 +327,6 @@ export function validateAndBuildQuerySnapshot(
         (colSpec) => _aggCol(colSpec, _col(colSpec)),
       ),
       // TODO: verify agg columns agree with pivot agg columns
-      // TODO: verify groupByExtend expression that all columns are accounted for
     };
   }
 
@@ -337,7 +336,7 @@ export function validateAndBuildQuerySnapshot(
   // --------------------------------- CAST ---------------------------------
   // TODO: @akphi - implement this
 
-  // --------------------------------- GROUP EXTEND ---------------------------------
+  // --------------------------------- GROUP-LEVEL EXTEND ---------------------------------
   // TODO: @akphi - implement this
 
   // --------------------------------- SORT ---------------------------------

package/src/stores/dataCube/core/aggregation/DataCubeQueryAggregationOperation.ts

@@ -0,0 +1,40 @@
+/**
+ * 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 {
+  DataCubeQuerySnapshotAggregateColumn,
+  DataCubeQuerySnapshotColumn,
+} from '../DataCubeQuerySnapshot.js';
+import { type V1_AppliedFunction } from '@finos/legend-graph';
+
+// --------------------------------- CONTRACT ---------------------------------
+
+export abstract class DataCubeQueryAggregationOperation {
+  abstract get label(): React.ReactNode;
+  abstract get textLabel(): string;
+  abstract get description(): string;
+  abstract get operator(): string;
+
+  abstract isCompatibleWithColumn(column: DataCubeQuerySnapshotColumn): boolean;
+
+  abstract buildAggregateColumnSnapshot(
+    expression: V1_AppliedFunction,
+  ): DataCubeQuerySnapshotAggregateColumn | undefined;
+
+  abstract buildAggregateColumn(
+    condition: DataCubeQuerySnapshotAggregateColumn,
+  ): V1_AppliedFunction | undefined;
+}