@finos/legend-query-builder 0.6.22 → 0.6.24

package/src/components/shared/LambdaParameterValuesEditor.tsx

@@ -19,8 +19,10 @@ import {
   Dialog,
   Modal,
   ModalBody,
+  ModalFooterButton,
   ModalFooter,
   ModalHeader,
+  ModalFooterStatus,
 } from '@finos/legend-art';
 import {
   type PureModel,
@@ -28,8 +30,8 @@ import {
   type ObserverContext,
   PrimitiveType,
 } from '@finos/legend-graph';
-import { prettyCONSTName } from '@finos/legend-shared';
 import { observer } from 'mobx-react-lite';
+import { useState } from 'react';
 import type { LambdaParametersState } from '../../stores/shared/LambdaParameterState.js';
 import { BasicValueSpecificationEditor } from './BasicValueSpecificationEditor.js';
 
@@ -41,12 +43,18 @@ export const LambdaParameterValuesEditor = observer(
     lambdaParametersState: LambdaParametersState;
   }) => {
     const { lambdaParametersState, graph, observerContext } = props;
+    const [isSubmitAction, setIsSubmitAction] = useState(false);
+    const [isClosingAction, setIsClosingAction] = useState(false);
     const valuesEdtiorState = lambdaParametersState.parameterValuesEditorState;
-    const close = (): void => valuesEdtiorState.close();
+    const close = (): void => {
+      setIsClosingAction(true);
+      valuesEdtiorState.close();
+    };
     const applicationStore = useApplicationStore();
     const submitAction = valuesEdtiorState.submitAction;
     const submit = applicationStore.guardUnhandledError(async () => {
       if (submitAction) {
+        setIsSubmitAction(true);
         close();
         await submitAction.handler();
       }
@@ -106,18 +114,23 @@ export const LambdaParameterValuesEditor = observer(
             })}
           </ModalBody>
           <ModalFooter>
+            {isClosingAction && (
+              <ModalFooterStatus> Closing...</ModalFooterStatus>
+            )}
             {submitAction && (
-              <button
-                className="btn modal__footer__close-btn"
-                title={submitAction.label}
+              <ModalFooterButton
+                inProgress={isSubmitAction}
+                inProgressText={`${submitAction.label}...`}
                 onClick={submit}
-              >
-                {prettyCONSTName(submitAction.label)}
-              </button>
+                text={submitAction.label}
+              />
             )}
-            <button className="btn modal__footer__close-btn" onClick={close}>
-              Close
-            </button>
+            <ModalFooterButton
+              inProgress={isClosingAction}
+              inProgressText={'Closing...'}
+              onClick={close}
+              text="Close"
+            />
           </ModalFooter>
         </Modal>
       </Dialog>

package/src/components/shared/QueryBuilderVariableSelector.tsx

@@ -133,7 +133,7 @@ export const VariableViewer = observer(
               <TimesIcon />
             </button>
             <VariableInfoTooltip variable={variable}>
-              <div className="value-spec-editor__variable__info">
+              <div className="query-builder__variables__variable__action value-spec-editor__variable__info">
                 <InfoCircleIcon />
               </div>
             </VariableInfoTooltip>

package/src/components/workflows/ClassQueryBuilder.tsx

@@ -157,7 +157,7 @@ const ClassQueryBuilderSetupPanelContent = observer(
                 filterOption={mappingFilterOption}
                 formatOptionLabel={getPackageableElementOptionFormatter({
                   darkMode: !applicationStore.TEMPORARY__isLightThemeEnabled,
-                  pureModel: queryBuilderState.graphManagerState.graph,
+                  graph: queryBuilderState.graphManagerState.graph,
                 })}
               />
             </div>

package/src/components/workflows/MappingQueryBuilder.tsx

@@ -151,7 +151,7 @@ const MappingQueryBuilderSetupPanelContent = observer(
                 filterOption={mappingFilterOption}
                 formatOptionLabel={getPackageableElementOptionFormatter({
                   darkMode: !applicationStore.TEMPORARY__isLightThemeEnabled,
-                  pureModel: queryBuilderState.graphManagerState.graph,
+                  graph: queryBuilderState.graphManagerState.graph,
                 })}
               />
             </div>

package/src/graphManager/QueryBuilderHashUtils.ts

@@ -67,20 +67,20 @@ export enum QUERY_BUILDER_HASH_STRUCTURE {
   WATERMARK_STATE = 'WATERMARK_STATE',
 
   // OLAPGroup state
-  TDS_OLAP_GROUPBY_STATE = 'TDS_OLAP_GROUPBY_STATE',
-  TDS_OLAP_GROUPBY_OPERATION_STATE = 'TDS_OLAP_GROUPBY_OPERATION_STATE',
-  TDS_OLAP_GROUPBY_AGG_OPERATION_STATE = 'TDS_OLAP_GROUPBY_AGG_OPERATION_STATE',
-  TDS_OLAP_GROUPBY_COLUMN_STATE = 'TDS_OLAP_GROUPBY_COLUMN_STATE',
-  TDS_OLAP_GROUPBY_COLUMN_SORTBY_STATE = 'TDS_OLAP_GROUPBY_COLUMN_SORTBY_STATE',
-  TDS_OLAP_OPERATOR_RANK = 'TDS_OLAP_OPERATOR_RANK',
-  TDS_OLAP_OPERATOR_AVERAGE_RANK = 'TDS_OLAP_OPERATOR_AVERAGE_RANK',
-  TDS_OLAP_OPERATOR_DENSE_RANK = 'TDS_OLAP_OPERATOR_DENSE_RANK',
-  TDS_OLAP_OPERATOR_ROW_NUMBER = 'TDS_OLAP_OPERATOR_ROW_NUMBER',
-  TDS_OLAP_OPERATOR_SUM = 'TDS_OLAP_OPERATOR_SUM',
-  TDS_OLAP_OPERATOR_MAX = 'TDS_OLAP_OPERATOR_MAX',
-  TDS_OLAP_OPERATOR_MIN = 'TDS_OLAP_OPERATOR_MIN',
-  TDS_OLAP_OPERATOR_COUNT = 'TDS_OLAP_OPERATOR_COUNT',
-  TDS_OLAP_OPERATOR_AVERAGE = 'TDS_OLAP_OPERATOR_AVERAGE',
+  TDS_WINDOW_GROUPBY_STATE = 'TDS_WINDOW_STATE',
+  TDS_WINDOW_GROUPBY_OPERATION_STATE = 'TDS_WINDOW_OPERATION_STATE',
+  TDS_WINDOW_GROUPBY_AGG_OPERATION_STATE = 'TDS_WINDOW_AGG_OPERATION_STATE',
+  TDS_WINDOW_COLUMN_STATE = 'TDS_WINDOW_COLUMN_STATE',
+  TDS_WINDOW_COLUMN_SORTBY_STATE = 'TDS_WINDOW_COLUMN_SORTBY_STATE',
+  TDS_WINDOW_OPERATOR_RANK = 'TDS_WINDOW_OPERATOR_RANK',
+  TDS_WINDOW_OPERATOR_AVERAGE_RANK = 'TDS_WINDOW_OPERATOR_AVERAGE_RANK',
+  TDS_WINDOW_OPERATOR_DENSE_RANK = 'TDS_WINDOW_OPERATOR_DENSE_RANK',
+  TDS_WINDOW_OPERATOR_ROW_NUMBER = 'TDS_WINDOW_OPERATOR_ROW_NUMBER',
+  TDS_WINDOW_OPERATOR_SUM = 'TDS_WINDOW_OPERATOR_SUM',
+  TDS_WINDOW_OPERATOR_MAX = 'TDS_WINDOW_OPERATOR_MAX',
+  TDS_WINDOW_OPERATOR_MIN = 'TDS_WINDOW_OPERATOR_MIN',
+  TDS_WINDOW_OPERATOR_COUNT = 'TDS_WINDOW_OPERATOR_COUNT',
+  TDS_WINDOW_OPERATOR_AVERAGE = 'TDS_WINDOW_OPERATOR_AVERAGE',
 
   // filter state
   FILTER_TREE_GROUP_NODE_DATA = 'FILTER_TREE_GROUP_NODE_DATA',

package/src/graphManager/QueryBuilderSupportedFunctions.ts

@@ -19,6 +19,7 @@ export enum QUERY_BUILDER_SUPPORTED_FUNCTIONS {
   EXISTS = 'meta::pure::functions::collection::exists',
   FILTER = 'meta::pure::functions::collection::filter',
   GET_ALL = 'meta::pure::functions::collection::getAll',
+  GET_ALL_VERSIONS = 'meta::pure::functions::collection::getAllVersions',
   NOT = 'meta::pure::functions::boolean::not',
   OR = 'meta::pure::functions::boolean::or',
   TAKE = 'meta::pure::functions::collection::take',

package/src/stores/QueryBuilderPreviewDataHelper.ts

@@ -141,7 +141,9 @@ export const buildNumericPreviewDataQuery = (
     aggregationState.changeColumnAggregateOperator(valAggOp, colState);
   });
 
-  return builderState.resultState.buildExecutionRawLambda();
+  return builderState.resultState.buildExecutionRawLambda({
+    useAllVersionsForMilestoning: true,
+  });
 };
 
 export const buildNonNumericPreviewDataQuery = (
@@ -198,5 +200,7 @@ export const buildNonNumericPreviewDataQuery = (
     sortValueCount,
     new SortColumnState(valueProjectionColState),
   ];
-  return builderState.resultState.buildExecutionRawLambda();
+  return builderState.resultState.buildExecutionRawLambda({
+    useAllVersionsForMilestoning: true,
+  });
 };

package/src/stores/QueryBuilderResultState.ts

@@ -42,6 +42,7 @@ import {
   buildExecutionParameterValues,
   getExecutionQueryFromRawLambda,
 } from './shared/LambdaParameterState.js';
+import type { LambdaFunctionBuilderOption } from './QueryBuilderValueSpecificationBuilderHelper.js';
 
 const DEFAULT_LIMIT = 1000;
 
@@ -51,6 +52,7 @@ export class QueryBuilderResultState {
   readonly executionPlanState: ExecutionPlanState;
 
   previewLimit = DEFAULT_LIMIT;
+  pressedRunQuery = ActionState.create();
   isRunningQuery = false;
   isGeneratingPlan = false;
   executionResult?: ExecutionResult | undefined;
@@ -113,11 +115,14 @@ export class QueryBuilderResultState {
     return false;
   }
 
-  buildExecutionRawLambda(): RawLambda {
+  buildExecutionRawLambda(
+    executionOptions?: LambdaFunctionBuilderOption,
+  ): RawLambda {
     let query: RawLambda;
     if (this.queryBuilderState.isQuerySupported) {
       const lambdaFunction = buildLambdaFunction(this.queryBuilderState, {
         isBuildingExecutionQuery: true,
+        ...executionOptions,
       });
       query = buildRawLambdaFromLambdaFunction(
         lambdaFunction,
@@ -241,6 +246,7 @@ export class QueryBuilderResultState {
       this.queryBuilderState.applicationStore.notifyError(error);
     } finally {
       this.setIsRunningQuery(false);
+      this.pressedRunQuery.complete();
     }
   }
 

package/src/stores/QueryBuilderStateBuilder.ts

@@ -66,7 +66,7 @@ import {
 } from './fetch-structure/tds/projection/QueryBuilderProjectionStateBuilder.js';
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../graphManager/QueryBuilderSupportedFunctions.js';
 import { LambdaParameterState } from './shared/LambdaParameterState.js';
-import { processTDS_OLAPGroupByExpression } from './fetch-structure/tds/olapGroupBy/QueryBuilderOLAPGroupByStateBuilder.js';
+import { processTDS_OLAPGroupByExpression } from './fetch-structure/tds/window/QueryBuilderWindowStateBuilder.js';
 import { processWatermarkExpression } from './watermark/QueryBuilderWatermarkStateBuilder.js';
 import { QueryBuilderConstantExpressionState } from './QueryBuilderConstantsState.js';
 

package/src/stores/QueryBuilderValueSpecificationBuilder.ts

@@ -57,6 +57,24 @@ const buildGetAllFunction = (
   return _func;
 };
 
+const buildGetAllVersionsFunction = (
+  _class: Class,
+  multiplicity: Multiplicity,
+): SimpleFunctionExpression => {
+  const _func = new SimpleFunctionExpression(
+    extractElementNameFromPath(
+      QUERY_BUILDER_SUPPORTED_FUNCTIONS.GET_ALL_VERSIONS,
+    ),
+  );
+  const classInstance = new InstanceValue(
+    multiplicity,
+    GenericTypeExplicitReference.create(new GenericType(_class)),
+  );
+  classInstance.values[0] = PackageableElementExplicitReference.create(_class);
+  _func.parametersValues.push(classInstance);
+  return _func;
+};
+
 const buildLetExpression = (
   constantExpressionState: QueryBuilderConstantExpressionState,
 ): SimpleFunctionExpression => {
@@ -101,20 +119,31 @@ export const buildLambdaFunction = (
     ),
   );
 
-  // build getAll()
-  const getAllFunction = buildGetAllFunction(_class, Multiplicity.ONE);
-
-  // build milestoning parameter(s) for getAll()
   const milestoningStereotype = getMilestoneTemporalStereotype(
     _class,
     queryBuilderState.graphManagerState.graph,
   );
-  if (milestoningStereotype) {
-    queryBuilderState.milestoningState
-      .getMilestoningImplementation(milestoningStereotype)
-      .buildGetAllParameters(getAllFunction);
+
+  if (milestoningStereotype && options?.useAllVersionsForMilestoning) {
+    // build getAllVersions() when we preview data for milestoned classes
+    // because if we use getAll() we need to pass in data to execute the query
+    // but we don't give user that option in this flow.
+    const getAllVersionsFunction = buildGetAllVersionsFunction(
+      _class,
+      Multiplicity.ONE,
+    );
+    lambdaFunction.expressionSequence[0] = getAllVersionsFunction;
+  } else {
+    // build getAll()
+    const getAllFunction = buildGetAllFunction(_class, Multiplicity.ONE);
+    if (milestoningStereotype) {
+      // build milestoning parameter(s) for getAll()
+      queryBuilderState.milestoningState
+        .getMilestoningImplementation(milestoningStereotype)
+        .buildGetAllParameters(getAllFunction);
+    }
+    lambdaFunction.expressionSequence[0] = getAllFunction;
   }
-  lambdaFunction.expressionSequence[0] = getAllFunction;
 
   // build watermark
   buildWatermarkExpression(queryBuilderState.watermarkState, lambdaFunction);
@@ -139,7 +168,10 @@ export const buildLambdaFunction = (
     ];
   }
   // build parameters
-  if (queryBuilderState.parametersState.parameterStates.length) {
+  if (
+    queryBuilderState.parametersState.parameterStates.length &&
+    !options?.useAllVersionsForMilestoning
+  ) {
     if (options?.isBuildingExecutionQuery) {
       buildExecutionQueryFromLambdaFunction(
         lambdaFunction,

package/src/stores/QueryBuilderValueSpecificationBuilderHelper.ts

@@ -16,9 +16,12 @@
 
 import {
   AbstractPropertyExpression,
+  Class,
   DerivedProperty,
   INTERNAL__PropagatedValue,
   matchFunctionName,
+  MILESTONING_VERSION_PROPERTY_SUFFIX,
+  PropertyExplicitReference,
   SimpleFunctionExpression,
   VariableExpression,
   type ValueSpecification,
@@ -30,7 +33,11 @@ import {
 } from '@finos/legend-shared';
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../graphManager/QueryBuilderSupportedFunctions.js';
 import type { QueryBuilderState } from './QueryBuilderState.js';
-import { variableExpression_setName } from './shared/ValueSpecificationModifierHelper.js';
+import {
+  functionExpression_setParametersValues,
+  propertyExpression_setFunc,
+  variableExpression_setName,
+} from './shared/ValueSpecificationModifierHelper.js';
 
 /**
  * Gets the value of ValueSpecification given INTERNAL__PropagatedValue is pointing to.
@@ -50,6 +57,7 @@ export const buildPropertyExpressionChain = (
   propertyExpression: AbstractPropertyExpression,
   queryBuilderState: QueryBuilderState,
   lambdaParameterName: string,
+  options?: LambdaFunctionBuilderOption,
   /**
    * As of now, we don't support date propagation for aggregation-class functions
    * so we have this temporary flag to disable date propagation, there could be other
@@ -81,45 +89,75 @@ export const buildPropertyExpressionChain = (
       currentExpression instanceof AbstractPropertyExpression &&
       currentExpression.func.value instanceof DerivedProperty
     ) {
-      const currentPropertyExpression = currentExpression;
-      const parameterValues = currentExpression.parametersValues.slice(1);
-      parameterValues.forEach((parameterValue, index) => {
-        if (parameterValue instanceof INTERNAL__PropagatedValue) {
-          // Replace with argumentless derived property expression only when default date propagation is supported
-          if (
-            !TEMPORARY__disableDatePropagation &&
-            parameterValue.isPropagatedValue
-          ) {
-            // NOTE: For `bitemporal` property check if the property expression has parameters which are not instance of
-            // `INTERNAL_PropagatedValue` then pass the parameters as user explicitly changed values of either of the parameters.
+      // check if we are building the expression chain to view preview data and if the
+      // the property is milestoned. If that is the case we need to replace the
+      // `property` with `propertyAllVersions`
+      if (
+        options?.useAllVersionsForMilestoning &&
+        currentExpression.func.value.genericType.value.rawType instanceof
+          Class &&
+        currentExpression.func.value._OWNER._generatedMilestonedProperties
+          .length !== 0
+      ) {
+        const name = currentExpression.func.value.name;
+        const property =
+          currentExpression.func.value._OWNER._generatedMilestonedProperties.find(
+            (e) =>
+              e.name ===
+              `${name}${MILESTONING_VERSION_PROPERTY_SUFFIX.ALL_VERSIONS}`,
+          );
+        if (property) {
+          propertyExpression_setFunc(
+            currentExpression,
+            PropertyExplicitReference.create(property),
+          );
+          functionExpression_setParametersValues(
+            currentExpression,
+            [guaranteeNonNullable(currentExpression.parametersValues[0])],
+            queryBuilderState.observableContext,
+          );
+        }
+      } else {
+        const currentPropertyExpression = currentExpression;
+        const parameterValues = currentExpression.parametersValues.slice(1);
+        parameterValues.forEach((parameterValue, index) => {
+          if (parameterValue instanceof INTERNAL__PropagatedValue) {
+            // Replace with argumentless derived property expression only when default date propagation is supported
             if (
-              (index === 1 &&
-                currentPropertyExpression.parametersValues.length === 3) ||
-              (index === 0 &&
-                currentPropertyExpression.parametersValues.length === 3 &&
-                !(
-                  currentPropertyExpression.parametersValues[2] instanceof
-                    INTERNAL__PropagatedValue &&
-                  currentPropertyExpression.parametersValues[2]
-                    .isPropagatedValue === true
-                ))
+              !TEMPORARY__disableDatePropagation &&
+              parameterValue.isPropagatedValue
             ) {
+              // NOTE: For `bitemporal` property check if the property expression has parameters which are not instance of
+              // `INTERNAL_PropagatedValue` then pass the parameters as user explicitly changed values of either of the parameters.
+              if (
+                (index === 1 &&
+                  currentPropertyExpression.parametersValues.length === 3) ||
+                (index === 0 &&
+                  currentPropertyExpression.parametersValues.length === 3 &&
+                  !(
+                    currentPropertyExpression.parametersValues[2] instanceof
+                      INTERNAL__PropagatedValue &&
+                    currentPropertyExpression.parametersValues[2]
+                      .isPropagatedValue === true
+                  ))
+              ) {
+                currentPropertyExpression.parametersValues[index + 1] =
+                  getValueOfInternalPropagatedValue(parameterValue);
+              } else {
+                currentPropertyExpression.parametersValues = [
+                  guaranteeNonNullable(
+                    guaranteeType(currentExpression, AbstractPropertyExpression)
+                      .parametersValues[0],
+                  ),
+                ];
+              }
+            } else {
               currentPropertyExpression.parametersValues[index + 1] =
                 getValueOfInternalPropagatedValue(parameterValue);
-            } else {
-              currentPropertyExpression.parametersValues = [
-                guaranteeNonNullable(
-                  guaranteeType(currentExpression, AbstractPropertyExpression)
-                    .parametersValues[0],
-                ),
-              ];
             }
-          } else {
-            currentPropertyExpression.parametersValues[index + 1] =
-              getValueOfInternalPropagatedValue(parameterValue);
           }
-        }
-      });
+        });
+      }
     }
     currentExpression = nextExpression;
     // Take care of chains of subtype (a pattern that is not useful, but we want to support and rectify)
@@ -150,5 +188,12 @@ export type LambdaFunctionBuilderOption = {
    * queryBuilderState will make the lambda function building process overrides several query values, such as the row limit.
    */
   isBuildingExecutionQuery?: boolean | undefined;
+
+  /**
+   * Set this to `true` when we construct query for execution within the app to view preview data.
+   * queryBuilderState will make the lambda function building process overrides `.all()` to `.allVersions()` if the Class
+   * is milestoned and `property` to `propertyAllVersions` if a property is milestoned.
+   */
+  useAllVersionsForMilestoning?: boolean | undefined;
   keepSourceInformation?: boolean | undefined;
 };

package/src/stores/fetch-structure/tds/QueryBuilderTDSState.ts

@@ -92,9 +92,9 @@ import type { LambdaFunctionBuilderOption } from '../../QueryBuilderValueSpecifi
 import { appendProjection } from './projection/QueryBuilderProjectionValueSpecificationBuilder.js';
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../graphManager/QueryBuilderSupportedFunctions.js';
 import { QUERY_BUILDER_HASH_STRUCTURE } from '../../../graphManager/QueryBuilderHashUtils.js';
-import { QueryBuilderOLAPGroupByState } from './olapGroupBy/QueryBuilderOLAPGroupByState.js';
-import type { QueryBuilderTDS_OLAPOperator } from './olapGroupBy/operators/QueryBuilderTDS_OLAPOperator.js';
-import { getQueryBuilderCoreOLAPGroupByOperators } from './olapGroupBy/QueryBuilderOLAPGroupByOperatorLoader.js';
+import { QueryBuilderWindowState } from './window/QueryBuilderWindowState.js';
+import type { QueryBuilderTDS_WindowOperator } from './window/operators/QueryBuilderTDS_WindowOperator.js';
+import { getQueryBuilderCoreWindowOperators } from './window/QueryBuilderWindowGroupByOperatorLoader.js';
 import type { QueryBuilderTDSColumnState } from './QueryBuilderTDSColumnState.js';
 
 export class QueryBuilderTDSState
@@ -103,19 +103,19 @@ export class QueryBuilderTDSState
 {
   readonly aggregationState: QueryBuilderAggregationState;
   readonly postFilterState: QueryBuilderPostFilterState;
-  readonly olapGroupByState: QueryBuilderOLAPGroupByState;
+  readonly windowState: QueryBuilderWindowState;
   readonly resultSetModifierState: QueryResultSetModifierState;
   projectionColumns: QueryBuilderProjectionColumnState[] = [];
   isConvertDerivationProjectionObjects = false;
   showPostFilterPanel = false;
-  showOlapGroupByPanel = false;
+  showWindowFuncPanel = false;
 
   postFilterOperators: QueryBuilderPostFilterOperator[] =
     getQueryBuilderCorePostFilterOperators();
   aggregationOperators: QueryBuilderAggregateOperator[] =
     getQueryBuilderCoreAggregrationOperators();
-  olapGroupByOperators: QueryBuilderTDS_OLAPOperator[] =
-    getQueryBuilderCoreOLAPGroupByOperators();
+  windowFuncOperators: QueryBuilderTDS_WindowOperator[] =
+    getQueryBuilderCoreWindowOperators();
 
   constructor(
     queryBuilderState: QueryBuilderState,
@@ -127,7 +127,7 @@ export class QueryBuilderTDSState
       projectionColumns: observable,
       isConvertDerivationProjectionObjects: observable,
       showPostFilterPanel: observable,
-      showOlapGroupByPanel: observable,
+      showWindowFuncPanel: observable,
       TEMPORARY__showPostFetchStructurePanel: computed,
       derivations: computed,
       hasParserError: computed,
@@ -135,7 +135,7 @@ export class QueryBuilderTDSState
       moveColumn: action,
       replaceColumn: action,
       setShowPostFilterPanel: action,
-      setShowOlapGroupByPanel: action,
+      setShowWindowFuncPanel: action,
       convertDerivationProjectionObjects: flow,
     });
 
@@ -148,9 +148,9 @@ export class QueryBuilderTDSState
       this,
       this.aggregationOperators,
     );
-    this.olapGroupByState = new QueryBuilderOLAPGroupByState(
+    this.windowState = new QueryBuilderWindowState(
       this,
-      this.olapGroupByOperators,
+      this.windowFuncOperators,
     );
   }
 
@@ -173,7 +173,7 @@ export class QueryBuilderTDSState
   override get TEMPORARY__showPostFetchStructurePanel(): boolean {
     return (
       this.queryBuilderState.filterState.showPanel ||
-      this.showOlapGroupByPanel ||
+      this.showWindowFuncPanel ||
       this.showPostFilterPanel
     );
   }
@@ -279,7 +279,7 @@ export class QueryBuilderTDSState
     return [
       ...this.aggregationState.columns,
       ...projectionColumns,
-      ...this.olapGroupByState.olapColumns,
+      ...this.windowState.windowColumns,
     ];
   }
 
@@ -293,7 +293,7 @@ export class QueryBuilderTDSState
     return Boolean(
       [
         ...this.postFilterState.referencedTDSColumns,
-        ...this.olapGroupByState.referencedTDSColumns,
+        ...this.windowState.referencedTDSColumns,
       ].find((col) => {
         if (col instanceof QueryBuilderAggregateColumnState) {
           return tdsCol instanceof QueryBuilderAggregateColumnState
@@ -320,8 +320,8 @@ export class QueryBuilderTDSState
     this.showPostFilterPanel = val;
   }
 
-  setShowOlapGroupByPanel(val: boolean): void {
-    this.showOlapGroupByPanel = val;
+  setShowWindowFuncPanel(val: boolean): void {
+    this.showWindowFuncPanel = val;
   }
 
   *convertDerivationProjectionObjects(): GeneratorFn<void> {

package/src/stores/fetch-structure/tds/post-filter/operators/QueryBuilderPostFilterOperatorHelper.ts

@@ -17,7 +17,7 @@
 import { Multiplicity } from '@finos/legend-graph';
 import { UnsupportedOperationError } from '@finos/legend-shared';
 import { QueryBuilderAggregateColumnState } from '../../aggregation/QueryBuilderAggregationState.js';
-import { QueryBuilderOLAPGroupByColumnState } from '../../olapGroupBy/QueryBuilderOLAPGroupByState.js';
+import { QueryBuilderWindowColumnState } from '../../window/QueryBuilderWindowState.js';
 import { QueryBuilderSimpleProjectionColumnState } from '../../projection/QueryBuilderProjectionColumnState.js';
 import type { QueryBuilderTDSColumnState } from '../../QueryBuilderTDSColumnState.js';
 
@@ -26,7 +26,7 @@ export const getColumnMultiplicity = (
 ): Multiplicity => {
   if (
     columnState instanceof QueryBuilderAggregateColumnState ||
-    columnState instanceof QueryBuilderOLAPGroupByColumnState
+    columnState instanceof QueryBuilderWindowColumnState
   ) {
     return Multiplicity.ONE;
   } else if (columnState instanceof QueryBuilderSimpleProjectionColumnState) {

package/src/stores/fetch-structure/tds/projection/QueryBuilderProjectionValueSpecificationBuilder.ts

@@ -47,7 +47,7 @@ import {
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../../graphManager/QueryBuilderSupportedFunctions.js';
 import { buildGenericLambdaFunctionInstanceValue } from '../../../QueryBuilderValueSpecificationHelper.js';
 import { buildPropertyExpressionChain } from '../../../QueryBuilderValueSpecificationBuilderHelper.js';
-import { appendOLAPGroupByState } from '../olapGroupBy/QueryBuilderOLAPGroupByValueSpecificationBuilder.js';
+import { appendOLAPGroupByState } from '../window/QueryBuilderWindowValueSpecificationBuilder.js';
 import { appendPostFilter } from '../post-filter/QueryBuilderPostFilterValueSpecificationBuilder.js';
 
 const buildSortExpression = (
@@ -227,6 +227,7 @@ export const appendProjection = (
               projectionColumnState.propertyExpressionState.propertyExpression,
               projectionColumnState.propertyExpressionState.queryBuilderState,
               projectionColumnState.lambdaParameterName,
+              options,
               true,
             ),
           ],
@@ -328,6 +329,7 @@ export const appendProjection = (
               projectionColumnState.propertyExpressionState.propertyExpression,
               projectionColumnState.propertyExpressionState.queryBuilderState,
               projectionColumnState.lambdaParameterName,
+              options,
             ),
           ],
           queryBuilderState.graphManagerState.graph,
@@ -368,7 +370,7 @@ export const appendProjection = (
   }
 
   // build olapGroupBy
-  appendOLAPGroupByState(tdsState.olapGroupByState, lambdaFunction);
+  appendOLAPGroupByState(tdsState.windowState, lambdaFunction);
 
   // build post-filter
   appendPostFilter(tdsState.postFilterState, lambdaFunction);

package/src/stores/fetch-structure/tds/window/QueryBuilderWindowGroupByOperatorLoader.ts

@@ -0,0 +1,39 @@
+/**
+ * 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 { QueryBuilderTDS_WindowOperator } from './operators/QueryBuilderTDS_WindowOperator.js';
+import { QueryBuilderTDS_WindowRankOperator_AverageRank } from './operators/QueryBuilderTDS_WindowRankOperator_AverageRank.js';
+import { QueryBuilderTDS_WindowRankOperator_DenseRank } from './operators/QueryBuilderTDS_WindowRankOperator_DenseRank.js';
+import { QueryBuilderTDS_WindowRankOperator_Rank } from './operators/QueryBuilderTDS_WindowRankOperator_Rank.js';
+import { QueryBuilderTDS_WindowRankOperator_RowNumber } from './operators/QueryBuilderTDS_WindowRankOperator_RowNumber.js';
+import { QueryBuilderTDS_WindowOperator_Sum } from './operators/QueryBuilderTDS_WindowOperator_Sum.js';
+import { QueryBuilderTDS_WindowOperator_Count } from './operators/QueryBuilderTDS_WindowOperator_Count.js';
+import { QueryBuilderTDS_WindowOperator_Max } from './operators/QueryBuilderTDS_WindowOperator_Max.js';
+import { QueryBuilderTDS_WindowOperator_Min } from './operators/QueryBuilderTDS_WindowOperator_Min.js';
+import { QueryBuilderTDS_WindowOperator_Average } from './operators/QueryBuilderTDS_WindowOperator_Average.js';
+
+export const getQueryBuilderCoreWindowOperators =
+  (): QueryBuilderTDS_WindowOperator[] => [
+    new QueryBuilderTDS_WindowOperator_Sum(),
+    new QueryBuilderTDS_WindowOperator_Count(),
+    new QueryBuilderTDS_WindowOperator_Max(),
+    new QueryBuilderTDS_WindowOperator_Min(),
+    new QueryBuilderTDS_WindowOperator_Average(),
+    new QueryBuilderTDS_WindowRankOperator_AverageRank(),
+    new QueryBuilderTDS_WindowRankOperator_DenseRank(),
+    new QueryBuilderTDS_WindowRankOperator_Rank(),
+    new QueryBuilderTDS_WindowRankOperator_RowNumber(),
+  ];