@finos/legend-query-builder 4.11.17 → 4.13.0

package/src/stores/QueryBuilderStateBuilder.ts

@@ -52,6 +52,7 @@ import {
   PackageableRuntime,
   RuntimePointer,
   PackageableElementExplicitReference,
+  MILESTONING_STEREOTYPE,
 } from '@finos/legend-graph';
 import { processTDSPostFilterExpression } from './fetch-structure/tds/post-filter/QueryBuilderPostFilterStateBuilder.js';
 import { processFilterExpression } from './filter/QueryBuilderFilterStateBuilder.js';
@@ -70,6 +71,7 @@ import {
   processTDSProjectExpression,
   processTDSProjectionColumnPropertyExpression,
   processTDSProjectionDerivationExpression,
+  processTDSSliceExpression,
   processTDSSortDirectionExpression,
   processTDSSortExpression,
   processTDSTakeExpression,
@@ -77,6 +79,7 @@ import {
 import {
   QUERY_BUILDER_SUPPORTED_FUNCTIONS,
   QUERY_BUILDER_SUPPORTED_CALENDAR_AGGREGATION_FUNCTIONS,
+  QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS,
 } from '../graph/QueryBuilderMetaModelConst.js';
 import { LambdaParameterState } from './shared/LambdaParameterState.js';
 import { processTDS_OLAPGroupByExpression } from './fetch-structure/tds/window/QueryBuilderWindowStateBuilder.js';
@@ -122,6 +125,87 @@ const processGetAllExpression = (
   }
 };
 
+const processGetAllVersionsExpression = (
+  expression: SimpleFunctionExpression,
+  queryBuilderState: QueryBuilderState,
+): void => {
+  const _class = expression.genericType?.value.rawType;
+  assertType(
+    _class,
+    Class,
+    `Can't process getAllVersions() expression: getAllVersions() return type is missing`,
+  );
+  queryBuilderState.setClass(_class);
+  queryBuilderState.milestoningState.clearMilestoningDates();
+  queryBuilderState.explorerState.refreshTreeData();
+
+  // check parameters (milestoning) and build state
+  const acceptedNoOfParameters = 1;
+  const stereotype = getMilestoneTemporalStereotype(
+    _class,
+    queryBuilderState.graphManagerState.graph,
+  );
+  assertNonNullable(
+    stereotype,
+    `Can't process getAllVersions() expression: getAllVersions() expects source class to be milestoned`,
+  );
+
+  assertTrue(
+    expression.parametersValues.length === acceptedNoOfParameters,
+    `Can't process getAllVersions() expression: getAllVersions() expects no arguments`,
+  );
+  queryBuilderState.setGetAllFunction(
+    QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS.GET_ALL_VERSIONS,
+  );
+};
+
+const processGetAllVersionsInRangeExpression = (
+  expression: SimpleFunctionExpression,
+  queryBuilderState: QueryBuilderState,
+): void => {
+  const _class = expression.genericType?.value.rawType;
+  assertType(
+    _class,
+    Class,
+    `Can't process getAllVersionsInRange() expression: getAllVersionsInRange() return type is missing`,
+  );
+  queryBuilderState.setClass(_class);
+  queryBuilderState.milestoningState.clearMilestoningDates();
+  queryBuilderState.explorerState.refreshTreeData();
+
+  // check parameters (milestoning) and build state
+  const acceptedNoOfParameters = 3;
+  const stereotype = getMilestoneTemporalStereotype(
+    _class,
+    queryBuilderState.graphManagerState.graph,
+  );
+  assertTrue(
+    stereotype !== undefined &&
+      stereotype !== MILESTONING_STEREOTYPE.BITEMPORAL,
+    `Can't process getAllVersionsInRange() expression: getAllVersionInRange() expects source class to be processing temporal or business temporal milestoned`,
+  );
+
+  assertTrue(
+    expression.parametersValues.length === acceptedNoOfParameters,
+    `Can't process getAllVersionsInRange() expression: getAllVersionsInRange() expects start and end date`,
+  );
+  queryBuilderState.setGetAllFunction(
+    QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS.GET_ALL_VERSIONS_IN_RANGE,
+  );
+  queryBuilderState.milestoningState.setStartDate(
+    guaranteeNonNullable(
+      expression.parametersValues[1],
+      `Can't process getAllVersionsInRange() expression: getAllVersionsInRange() expects start date to be defined`,
+    ),
+  );
+  queryBuilderState.milestoningState.setEndDate(
+    guaranteeNonNullable(
+      expression.parametersValues[2],
+      `Can't process getAllVersionsInRange() expression: getAllVersionsInRange() expects end date to be defined`,
+    ),
+  );
+};
+
 const processLetExpression = (
   expression: SimpleFunctionExpression,
   queryBuilderState: QueryBuilderState,
@@ -381,10 +465,35 @@ export class QueryBuilderValueSpecificationProcessor
   ): void {
     const functionName = valueSpecification.functionName;
     if (
-      matchFunctionName(functionName, QUERY_BUILDER_SUPPORTED_FUNCTIONS.GET_ALL)
+      matchFunctionName(
+        functionName,
+        QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS.GET_ALL,
+      )
     ) {
       processGetAllExpression(valueSpecification, this.queryBuilderState);
       return;
+    } else if (
+      matchFunctionName(
+        functionName,
+        QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS.GET_ALL_VERSIONS,
+      )
+    ) {
+      processGetAllVersionsExpression(
+        valueSpecification,
+        this.queryBuilderState,
+      );
+      return;
+    } else if (
+      matchFunctionName(
+        functionName,
+        QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS.GET_ALL_VERSIONS_IN_RANGE,
+      )
+    ) {
+      processGetAllVersionsInRangeExpression(
+        valueSpecification,
+        this.queryBuilderState,
+      );
+      return;
     } else if (
       matchFunctionName(
         functionName,
@@ -427,10 +536,11 @@ export class QueryBuilderValueSpecificationProcessor
       );
 
       if (
-        matchFunctionName(
-          precedingExpression.functionName,
-          QUERY_BUILDER_SUPPORTED_FUNCTIONS.GET_ALL,
-        )
+        matchFunctionName(precedingExpression.functionName, [
+          QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS.GET_ALL,
+          QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS.GET_ALL_VERSIONS,
+          QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS.GET_ALL_VERSIONS_IN_RANGE,
+        ])
       ) {
         assertTrue(
           matchFunctionName(
@@ -532,6 +642,15 @@ export class QueryBuilderValueSpecificationProcessor
         this.parentLambda,
       );
       return;
+    } else if (
+      matchFunctionName(functionName, QUERY_BUILDER_SUPPORTED_FUNCTIONS.SLICE)
+    ) {
+      processTDSSliceExpression(
+        valueSpecification,
+        this.queryBuilderState,
+        this.parentLambda,
+      );
+      return;
     } else if (
       matchFunctionName(functionName, [
         QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_ASC,

package/src/stores/QueryBuilderValueSpecificationBuilder.ts

@@ -14,7 +14,11 @@
  * limitations under the License.
  */
 
-import { guaranteeNonNullable, guaranteeType } from '@finos/legend-shared';
+import {
+  UnsupportedOperationError,
+  guaranteeNonNullable,
+  guaranteeType,
+} from '@finos/legend-shared';
 import {
   type Class,
   Multiplicity,
@@ -35,7 +39,7 @@ import type { QueryBuilderState } from './QueryBuilderState.js';
 import { buildFilterExpression } from './filter/QueryBuilderFilterValueSpecificationBuilder.js';
 import type { LambdaFunctionBuilderOption } from './QueryBuilderValueSpecificationBuilderHelper.js';
 import type { QueryBuilderFetchStructureState } from './fetch-structure/QueryBuilderFetchStructureState.js';
-import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../graph/QueryBuilderMetaModelConst.js';
+import { QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS } from '../graph/QueryBuilderMetaModelConst.js';
 import { buildWatermarkExpression } from './watermark/QueryBuilderWatermarkValueSpecificationBuilder.js';
 import { buildExecutionQueryFromLambdaFunction } from './shared/LambdaParameterState.js';
 import {
@@ -48,7 +52,27 @@ export const buildGetAllFunction = (
   multiplicity: Multiplicity,
 ): SimpleFunctionExpression => {
   const _func = new SimpleFunctionExpression(
-    extractElementNameFromPath(QUERY_BUILDER_SUPPORTED_FUNCTIONS.GET_ALL),
+    extractElementNameFromPath(
+      QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS.GET_ALL,
+    ),
+  );
+  const classInstance = new InstanceValue(
+    multiplicity,
+    GenericTypeExplicitReference.create(new GenericType(_class)),
+  );
+  classInstance.values[0] = PackageableElementExplicitReference.create(_class);
+  _func.parametersValues.push(classInstance);
+  return _func;
+};
+
+export const buildGetAllVersionsInRangeFunction = (
+  _class: Class,
+  multiplicity: Multiplicity,
+): SimpleFunctionExpression => {
+  const _func = new SimpleFunctionExpression(
+    extractElementNameFromPath(
+      QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS.GET_ALL_VERSIONS_IN_RANGE,
+    ),
   );
   const classInstance = new InstanceValue(
     multiplicity,
@@ -65,7 +89,7 @@ const buildGetAllVersionsFunction = (
 ): SimpleFunctionExpression => {
   const _func = new SimpleFunctionExpression(
     extractElementNameFromPath(
-      QUERY_BUILDER_SUPPORTED_FUNCTIONS.GET_ALL_VERSIONS,
+      QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS.GET_ALL_VERSIONS,
     ),
   );
   const classInstance = new InstanceValue(
@@ -159,15 +183,55 @@ export const buildLambdaFunction = (
     );
     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);
+    switch (queryBuilderState.getAllFunction) {
+      case QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS.GET_ALL_VERSIONS: {
+        if (milestoningStereotype) {
+          const getAllVersionsFunction = buildGetAllVersionsFunction(
+            _class,
+            Multiplicity.ONE,
+          );
+          lambdaFunction.expressionSequence[0] = getAllVersionsFunction;
+        } else {
+          throw new UnsupportedOperationError(
+            `Unable to build query lamdba: getAllVersions() expects source class to be milestoned`,
+          );
+        }
+        break;
+      }
+      case QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS.GET_ALL_VERSIONS_IN_RANGE: {
+        if (milestoningStereotype) {
+          const getAllVersionsInRangeFunction =
+            buildGetAllVersionsInRangeFunction(_class, Multiplicity.ONE);
+          queryBuilderState.milestoningState
+            .getMilestoningImplementation(milestoningStereotype)
+            .buildGetAllVersionsInRangeParameters(
+              getAllVersionsInRangeFunction,
+            );
+          lambdaFunction.expressionSequence[0] = getAllVersionsInRangeFunction;
+        } else {
+          throw new UnsupportedOperationError(
+            `Unable to build query lamdba: getAllVersionsInRange() expects source class to be milestoned`,
+          );
+        }
+        break;
+      }
+      case QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS.GET_ALL: {
+        // 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;
+        break;
+      }
+      default:
+        throw new UnsupportedOperationError(
+          `Unable to build query lambda: unknown ${queryBuilderState.getAllFunction} function`,
+        );
     }
-    lambdaFunction.expressionSequence[0] = getAllFunction;
   }
 
   // build watermark

package/src/stores/fetch-structure/graph-fetch/QueryBuilderGraphFetchTreeStateBuilder.ts

@@ -46,6 +46,7 @@ import {
 import {
   QUERY_BUILDER_PURE_PATH,
   QUERY_BUILDER_SUPPORTED_FUNCTIONS,
+  QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS,
 } from '../../../graph/QueryBuilderMetaModelConst.js';
 import { type QueryBuilderState } from '../../QueryBuilderState.js';
 import { QueryBuilderValueSpecificationProcessor } from '../../QueryBuilderStateBuilder.js';
@@ -82,7 +83,9 @@ export const processGraphFetchExpression = (
   assertTrue(
     matchFunctionName(precedingExpression.functionName, [
       QUERY_BUILDER_SUPPORTED_FUNCTIONS.FILTER,
-      QUERY_BUILDER_SUPPORTED_FUNCTIONS.GET_ALL,
+      QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS.GET_ALL,
+      QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS.GET_ALL_VERSIONS,
+      QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS.GET_ALL_VERSIONS_IN_RANGE,
     ]),
     `Can't process ${functionName}(): only support ${functionName}() immediately following either getAll() or filter()`,
   );

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

@@ -65,6 +65,7 @@ export class QueryResultSetModifierState implements Hashable {
   limit?: number | undefined;
   distinct = false;
   sortColumns: SortColumnState[] = [];
+  slice: [number, number] | undefined;
 
   constructor(tdsState: QueryBuilderTDSState) {
     makeObservable(this, {
@@ -72,12 +73,14 @@ export class QueryResultSetModifierState implements Hashable {
       limit: observable,
       distinct: observable,
       sortColumns: observable,
+      slice: observable.ref,
       setShowModal: action,
       setLimit: action,
       toggleDistinct: action,
       deleteSortColumn: action,
       addSortColumn: action,
       updateSortColumns: action,
+      setSlice: action,
       reset: action,
       hashCode: computed,
     });
@@ -111,6 +114,10 @@ export class QueryResultSetModifierState implements Hashable {
     );
   }
 
+  setSlice(slice: [number, number] | undefined): void {
+    this.slice = slice;
+  }
+
   reset(): void {
     this.sortColumns = [];
     this.distinct = false;

package/src/stores/fetch-structure/tds/aggregation/QueryBuilderAggregationStateBuilder.ts

@@ -31,7 +31,10 @@ import {
   returnUndefOnError,
   UnsupportedOperationError,
 } from '@finos/legend-shared';
-import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../../graph/QueryBuilderMetaModelConst.js';
+import {
+  QUERY_BUILDER_SUPPORTED_FUNCTIONS,
+  QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS,
+} from '../../../../graph/QueryBuilderMetaModelConst.js';
 import type { QueryBuilderState } from '../../../QueryBuilderState.js';
 import { QueryBuilderValueSpecificationProcessor } from '../../../QueryBuilderStateBuilder.js';
 import { extractNullableStringFromInstanceValue } from '../../../QueryBuilderValueSpecificationHelper.js';
@@ -202,7 +205,9 @@ export const processTDSGroupByExpression = (
   );
   assertTrue(
     matchFunctionName(precedingExpression.functionName, [
-      QUERY_BUILDER_SUPPORTED_FUNCTIONS.GET_ALL,
+      QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS.GET_ALL,
+      QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS.GET_ALL_VERSIONS,
+      QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS.GET_ALL_VERSIONS_IN_RANGE,
       QUERY_BUILDER_SUPPORTED_FUNCTIONS.FILTER,
     ]),
     `Can't process groupBy() expression: only support groupBy() immediately following either getAll() or filter()`,

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

@@ -27,11 +27,13 @@ import {
   V1_deserializeRawValueSpecification,
   V1_RawLambda,
   VariableExpression,
+  PrimitiveInstanceValue,
 } from '@finos/legend-graph';
 import {
   assertNonNullable,
   assertTrue,
   assertType,
+  guaranteeIsNumber,
   guaranteeNonNullable,
   guaranteeType,
   isNonNullable,
@@ -40,6 +42,7 @@ import {
 import {
   COLUMN_SORT_TYPE,
   QUERY_BUILDER_SUPPORTED_FUNCTIONS,
+  QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS,
 } from '../../../../graph/QueryBuilderMetaModelConst.js';
 import type { QueryBuilderState } from '../../../QueryBuilderState.js';
 import { QueryBuilderValueSpecificationProcessor } from '../../../QueryBuilderStateBuilder.js';
@@ -80,7 +83,9 @@ export const processTDSProjectExpression = (
   );
   assertTrue(
     matchFunctionName(precedingExpression.functionName, [
-      QUERY_BUILDER_SUPPORTED_FUNCTIONS.GET_ALL,
+      QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS.GET_ALL,
+      QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS.GET_ALL_VERSIONS,
+      QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS.GET_ALL_VERSIONS_IN_RANGE,
       QUERY_BUILDER_SUPPORTED_FUNCTIONS.FILTER,
       QUERY_BUILDER_SUPPORTED_FUNCTIONS.WATERMARK,
     ]),
@@ -382,6 +387,68 @@ export const processTDSSortExpression = (
   );
 };
 
+export const processTDSSliceExpression = (
+  exp: SimpleFunctionExpression,
+  queryBuilderState: QueryBuilderState,
+  parentLambda: LambdaFunction,
+): void => {
+  // check parameters
+  assertTrue(
+    exp.parametersValues.length === 3,
+    `Can't process slice() expression: slice() expects 2 argument`,
+  );
+
+  // check preceding expression
+  const precedingExpression = guaranteeType(
+    exp.parametersValues[0],
+    SimpleFunctionExpression,
+    `Can't process slice() expression: only support slice() immediately following an expression`,
+  );
+  assertTrue(
+    matchFunctionName(precedingExpression.functionName, [
+      QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_TAKE,
+      QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_DISTINCT,
+      QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_SORT,
+      QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_PROJECT,
+      QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_GROUP_BY,
+      QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_FILTER,
+      QUERY_BUILDER_SUPPORTED_FUNCTIONS.OLAP_GROUPBY,
+    ]),
+    `Can't process slice() expression: only support slice() in TDS expression`,
+  );
+  QueryBuilderValueSpecificationProcessor.process(
+    precedingExpression,
+    parentLambda,
+    queryBuilderState,
+  );
+
+  // build state
+  if (
+    queryBuilderState.fetchStructureState.implementation instanceof
+    QueryBuilderTDSState
+  ) {
+    const tdsState = queryBuilderState.fetchStructureState.implementation;
+    const start = guaranteeIsNumber(
+      guaranteeType(
+        exp.parametersValues[1],
+        PrimitiveInstanceValue,
+        'Can`t process slice() function: first param should be a primitive instance value',
+      ).values[0],
+      'Can`t process slice() function: first param should be a number primitive instance value',
+    );
+
+    const end = guaranteeIsNumber(
+      guaranteeType(
+        exp.parametersValues[2],
+        PrimitiveInstanceValue,
+        'Can`t process slice() function: first param should be a primitive instance value',
+      ).values[0],
+      'Can`t process slice() function: first param should be a number primitive instance value',
+    );
+    tdsState.resultSetModifierState.setSlice([start, end]);
+  }
+};
+
 export const processTDSSortDirectionExpression = (
   expression: SimpleFunctionExpression,
   parentExpression: SimpleFunctionExpression | undefined,

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

@@ -136,6 +136,33 @@ const appendResultSetModifier = (
           takeFunction.parametersValues[1] = limit;
           currentExpression = takeFunction;
         }
+        // build slice()
+        if (resultModifierState.slice) {
+          const sliceStart = resultModifierState.slice[0];
+          const sliceEnd = resultModifierState.slice[1];
+          const startVal = new PrimitiveInstanceValue(
+            GenericTypeExplicitReference.create(
+              new GenericType(PrimitiveType.INTEGER),
+            ),
+          );
+          const endVal = new PrimitiveInstanceValue(
+            GenericTypeExplicitReference.create(
+              new GenericType(PrimitiveType.INTEGER),
+            ),
+          );
+          startVal.values = [sliceStart];
+          endVal.values = [sliceEnd];
+          const sliceFunction = new SimpleFunctionExpression(
+            extractElementNameFromPath(QUERY_BUILDER_SUPPORTED_FUNCTIONS.SLICE),
+          );
+          sliceFunction.parametersValues = [
+            currentExpression,
+            startVal,
+            endVal,
+          ];
+          currentExpression = sliceFunction;
+        }
+
         lambdaFunction.expressionSequence[0] = currentExpression;
         return lambdaFunction;
       }

package/src/stores/milestoning/QueryBuilderBitemporalMilestoningImplementation.ts

@@ -25,6 +25,7 @@ import {
   PrimitiveType,
 } from '@finos/legend-graph';
 import {
+  UnsupportedOperationError,
   assertTrue,
   guaranteeNonNullable,
   guaranteeType,
@@ -104,6 +105,14 @@ export class QueryBuilderBitemporalMilestoningImplementation extends QueryBuilde
     getAllFunction.parametersValues.push(parameterValue);
   }
 
+  buildGetAllVersionsInRangeParameters(
+    getAllVersionsInRangeFunction: SimpleFunctionExpression,
+  ): void {
+    throw new UnsupportedOperationError(
+      `Can't build getAllVersionsInRange() function: expects root class to be business temporal or processing temporal milestoned`,
+    );
+  }
+
   generateMilestoningDate(
     isDatePropagationSupported: boolean,
     hasDefaultMilestoningDate: boolean,

package/src/stores/milestoning/QueryBuilderBusinessTemporalMilestoningImplementation.ts

@@ -23,7 +23,11 @@ import {
   INTERNAL__PropagatedValue,
   PrimitiveType,
 } from '@finos/legend-graph';
-import { assertTrue, guaranteeNonNullable } from '@finos/legend-shared';
+import {
+  UnsupportedOperationError,
+  assertTrue,
+  guaranteeNonNullable,
+} from '@finos/legend-shared';
 import { getParameterValue } from '../../components/QueryBuilderSideBar.js';
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../graph/QueryBuilderMetaModelConst.js';
 import { createSupportedFunctionExpression } from '../shared/ValueSpecificationEditorHelper.js';
@@ -67,6 +71,23 @@ export class QueryBuilderBusinessTemporalMilestoningImplementation extends Query
     );
   }
 
+  buildGetAllVersionsInRangeParameters(
+    getAllVersionsInRangeFunction: SimpleFunctionExpression,
+  ): void {
+    if (this.milestoningState.startDate && this.milestoningState.endDate) {
+      getAllVersionsInRangeFunction.parametersValues.push(
+        this.milestoningState.startDate,
+      );
+      getAllVersionsInRangeFunction.parametersValues.push(
+        this.milestoningState.endDate,
+      );
+    } else {
+      throw new UnsupportedOperationError(
+        `Can't build getAllVersionsInRange() function: expected both startDate and endDate`,
+      );
+    }
+  }
+
   buildGetAllWithDefaultParameters(
     getAllFunction: SimpleFunctionExpression,
   ): void {

package/src/stores/milestoning/QueryBuilderMilestoningHelper.ts

@@ -110,6 +110,13 @@ export const isDefaultDatePropagationSupported = (
   ) {
     return false;
   }
+  if (
+    !prevPropertyExpression &&
+    property.genericType.value.rawType instanceof Class &&
+    queryBuilderState.milestoningState.isAllVersionsEnabled
+  ) {
+    return false;
+  }
   if (property.genericType.value.rawType instanceof Class) {
     // the stereotype of source class of current property expression.
     const sourceStereotype =

package/src/stores/milestoning/QueryBuilderMilestoningImplementation.ts

@@ -63,6 +63,13 @@ export abstract class QueryBuilderMilestoningImplementation {
     getAllFunction: SimpleFunctionExpression,
   ): void;
 
+  /**
+   * Builds parameters for getAllVersionsInRange() function with milestoned class
+   */
+  abstract buildGetAllVersionsInRangeParameters(
+    getAllVersionsInRangeFunction: SimpleFunctionExpression,
+  ): void;
+
   /**
    * Builds parameters for getAll() function with milestoned class
    */