@finos/legend-query-builder 4.17.100 → 4.18.1

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

@@ -22,19 +22,38 @@ import {
   GenericTypeExplicitReference,
   PrimitiveInstanceValue,
   SimpleFunctionExpression,
+  FunctionExpression,
   VariableExpression,
   Multiplicity,
   PrimitiveType,
+  ColSpec,
+  ColSpecArray,
+  ColSpecArrayInstance,
+  ColSpecInstanceValue,
+  RelationColumn,
 } from '@finos/legend-graph';
-import { guaranteeNonNullable } from '@finos/legend-shared';
+import {
+  guaranteeNonNullable,
+  UnsupportedOperationError,
+} from '@finos/legend-shared';
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../../graph/QueryBuilderMetaModelConst.js';
 import { buildGenericLambdaFunctionInstanceValue } from '../../../QueryBuilderValueSpecificationHelper.js';
-import { getFunctionNameFromTDSSortColumn } from '../QueryBuilderTDSHelper.js';
+import {
+  getFunctionNameFromTDSSortColumn,
+  getFunctionNameFromRelationSortColumn,
+} from '../QueryBuilderTDSHelper.js';
 import {
   type QueryBuilderWindowColumnState,
   type QueryBuilderWindowState,
   QueryBuilderTDS_WindowAggreationOperatorState,
+  QueryBuilderTDS_WindowRankOperatorState,
 } from './QueryBuilderWindowState.js';
+import { DEFAULT_LAMBDA_VARIABLE_NAME } from '@finos/legend-data-cube';
+import {
+  DEFAULT_WINDOW_FUNCTION_PARTITION_VAR_NAME,
+  DEFAULT_WINDOW_FUNCTION_ROW_VAR_NAME,
+  DEFAULT_WINDOW_FUNCTION_WINDOW_VAR_NAME,
+} from '../../../QueryBuilderConfig.js';
 
 const appendOLAPGroupByColumnState = (
   olapGroupByColumnState: QueryBuilderWindowColumnState,
@@ -78,16 +97,20 @@ const appendOLAPGroupByColumnState = (
 
   // create olap operation expression
   const operationState = olapGroupByColumnState.operatorState;
-  const olapFunc = extractElementNameFromPath(operationState.operator.pureFunc);
+  const lambdaParameterName =
+    operationState.lambdaParameterNames[0] ?? DEFAULT_LAMBDA_VARIABLE_NAME;
+  const olapFunc = extractElementNameFromPath(
+    guaranteeNonNullable(
+      operationState.operator.pureFunc,
+      `Operator '${operationState.operator.getLabel()}' does not have a compatible OLAP function`,
+    ),
+  );
   const olapFuncExpression = new SimpleFunctionExpression(olapFunc);
   olapFuncExpression.parametersValues = [
-    new VariableExpression(
-      operationState.lambdaParameterName,
-      Multiplicity.ONE,
-    ),
+    new VariableExpression(lambdaParameterName, Multiplicity.ONE),
   ];
   const olapLambdaFuncInstance = buildGenericLambdaFunctionInstanceValue(
-    operationState.lambdaParameterName,
+    [lambdaParameterName],
     [olapFuncExpression],
     graph,
   );
@@ -132,12 +155,227 @@ const appendOLAPGroupByColumnState = (
   return lambda;
 };
 
-export const appendOLAPGroupByState = (
-  olapGroupByState: QueryBuilderWindowState,
+export const appendOverExpression = (
+  extendColumnState: QueryBuilderWindowColumnState,
+): SimpleFunctionExpression => {
+  const overExpression = new SimpleFunctionExpression(
+    extractElementNameFromPath(QUERY_BUILDER_SUPPORTED_FUNCTIONS.RELATION_OVER),
+  );
+
+  //TODO: handle over() where the first parameter is a ColSpec
+  const colSpecArrayInstance = new ColSpecArrayInstance(
+    Multiplicity.ONE,
+    undefined,
+  );
+  const colSpecArray = new ColSpecArray();
+  colSpecArrayInstance.values = [colSpecArray];
+
+  extendColumnState.windowColumns.forEach((column) => {
+    const colSpec = new ColSpec();
+    colSpec.name = column.columnName;
+    colSpecArray.colSpecs.push(colSpec);
+  });
+  overExpression.parametersValues.push(colSpecArrayInstance);
+
+  if (extendColumnState.sortByState) {
+    const sortByState = extendColumnState.sortByState;
+    const sortByFunction = new SimpleFunctionExpression(
+      getFunctionNameFromRelationSortColumn(sortByState.sortType),
+    );
+    const sortColSpec = new ColSpecInstanceValue(Multiplicity.ONE, undefined);
+    const sortCol = new ColSpec();
+    sortCol.name = sortByState.columnState.columnName;
+    sortColSpec.values = [sortCol];
+    sortByFunction.parametersValues[0] = sortColSpec;
+
+    const sortByCollection = new CollectionInstanceValue(Multiplicity.ONE);
+    sortByCollection.values = [sortByFunction];
+
+    overExpression.parametersValues.push(sortByCollection);
+  }
+
+  return overExpression;
+};
+
+const appendExtendColumnState = (
+  extendColumnState: QueryBuilderWindowColumnState,
   lambda: LambdaFunction,
 ): LambdaFunction => {
-  olapGroupByState.windowColumns.forEach((c) =>
-    appendOLAPGroupByColumnState(c, lambda),
+  const graph =
+    extendColumnState.windowState.tdsState.queryBuilderState.graphManagerState
+      .graph;
+
+  const overExpression = appendOverExpression(extendColumnState);
+
+  const operatorColSpecArrayInst = new ColSpecArrayInstance(
+    Multiplicity.ONE,
+    undefined,
   );
+  const operatorColSpecArray = new ColSpecArray();
+  operatorColSpecArrayInst.values = [operatorColSpecArray];
+
+  const operatorColSpec = new ColSpec();
+  operatorColSpec.name = extendColumnState.columnName;
+
+  const operatorState = extendColumnState.operatorState;
+  if (operatorState.lambdaParameterNames.length === 1) {
+    //this was previously nontyped, so need to add window function parameters
+    operatorState.setLambdaParameterNames([
+      DEFAULT_WINDOW_FUNCTION_PARTITION_VAR_NAME,
+      DEFAULT_WINDOW_FUNCTION_WINDOW_VAR_NAME,
+      DEFAULT_WINDOW_FUNCTION_ROW_VAR_NAME,
+    ]);
+  }
+
+  if (
+    operatorState instanceof QueryBuilderTDS_WindowAggreationOperatorState &&
+    operatorState.operator.relationFunc
+  ) {
+    const operatorFunc = extractElementNameFromPath(
+      operatorState.operator.relationFunc,
+    );
+
+    //parameters
+    const [
+      partitionParam = DEFAULT_WINDOW_FUNCTION_PARTITION_VAR_NAME,
+      windowParam = DEFAULT_WINDOW_FUNCTION_WINDOW_VAR_NAME,
+      rowParam = DEFAULT_WINDOW_FUNCTION_ROW_VAR_NAME,
+      aggParam = DEFAULT_LAMBDA_VARIABLE_NAME,
+    ] = operatorState.lambdaParameterNames;
+
+    // Build function1: the map lambda {p, w, r|$r.SOURCE_COL}
+    const columnAccessExpression = new FunctionExpression(
+      operatorState.columnState.columnName,
+    );
+    columnAccessExpression.func = new RelationColumn(
+      operatorState.columnState.columnName,
+      GenericTypeExplicitReference.create(
+        new GenericType(PrimitiveType.STRING),
+      ),
+    );
+    columnAccessExpression.parametersValues = [
+      new VariableExpression(rowParam, Multiplicity.ONE),
+    ];
+
+    const mapLambda = buildGenericLambdaFunctionInstanceValue(
+      [partitionParam, windowParam, rowParam],
+      [columnAccessExpression],
+      graph,
+    );
+
+    operatorColSpec.function1 = mapLambda;
+
+    // Build function2: the reduce lambda x|$x->operatorFunc()
+    const operatorFuncExpression = new SimpleFunctionExpression(operatorFunc);
+    operatorFuncExpression.parametersValues = [
+      new VariableExpression(aggParam, Multiplicity.ONE),
+    ];
+
+    //build col spec
+    const function2 = buildGenericLambdaFunctionInstanceValue(
+      [aggParam],
+      [operatorFuncExpression],
+      graph,
+    );
+
+    operatorColSpec.function2 = function2;
+
+    operatorColSpecArray.colSpecs.push(operatorColSpec);
+
+    const extendExpression = new SimpleFunctionExpression(
+      extractElementNameFromPath(
+        QUERY_BUILDER_SUPPORTED_FUNCTIONS.RELATION_EXTEND,
+      ),
+    );
+    const currentExpression = guaranteeNonNullable(
+      lambda.expressionSequence[0],
+    );
+    extendExpression.parametersValues = [
+      currentExpression,
+      overExpression,
+      operatorColSpecArrayInst,
+    ];
+    lambda.expressionSequence[0] = extendExpression;
+    return lambda;
+  } else if (
+    operatorState instanceof QueryBuilderTDS_WindowRankOperatorState &&
+    operatorState.operator.relationFunc
+  ) {
+    const operatorFunc = extractElementNameFromPath(
+      operatorState.operator.relationFunc,
+    );
+    const operatorFuncExpression = new SimpleFunctionExpression(operatorFunc);
+    const [
+      partitionParam = DEFAULT_WINDOW_FUNCTION_PARTITION_VAR_NAME,
+      windowParam = DEFAULT_WINDOW_FUNCTION_WINDOW_VAR_NAME,
+      rowParam = DEFAULT_WINDOW_FUNCTION_ROW_VAR_NAME,
+    ] = operatorState.lambdaParameterNames;
+
+    if (
+      operatorFunc ===
+      extractElementNameFromPath(
+        QUERY_BUILDER_SUPPORTED_FUNCTIONS.RELATION_ROW_NUMBER,
+      )
+    ) {
+      operatorFuncExpression.parametersValues = [
+        new VariableExpression(partitionParam, Multiplicity.ONE),
+        new VariableExpression(rowParam, Multiplicity.ONE),
+      ];
+    } else {
+      operatorFuncExpression.parametersValues = [
+        new VariableExpression(partitionParam, Multiplicity.ONE),
+        new VariableExpression(windowParam, Multiplicity.ONE),
+        new VariableExpression(rowParam, Multiplicity.ONE),
+      ];
+    }
+
+    const rankLambda = buildGenericLambdaFunctionInstanceValue(
+      [partitionParam, windowParam, rowParam],
+      [operatorFuncExpression],
+      graph,
+    );
+
+    operatorColSpec.function1 = rankLambda;
+    operatorColSpecArray.colSpecs.push(operatorColSpec);
+
+    const extendExpression = new SimpleFunctionExpression(
+      extractElementNameFromPath(
+        QUERY_BUILDER_SUPPORTED_FUNCTIONS.RELATION_EXTEND,
+      ),
+    );
+
+    const currentExpression = guaranteeNonNullable(
+      lambda.expressionSequence[0],
+    );
+    extendExpression.parametersValues = [
+      currentExpression,
+      overExpression,
+      operatorColSpecArrayInst,
+    ];
+
+    lambda.expressionSequence[0] = extendExpression;
+    return lambda;
+  } else {
+    throw new UnsupportedOperationError(
+      `Unsupported window function. Function must be supported for typed TDS and be an aggregation or rank function.`,
+    );
+  }
+};
+
+export const appendWindowFunctionState = (
+  olapGroupByState: QueryBuilderWindowState,
+  lambda: LambdaFunction,
+): LambdaFunction => {
+  const typedTds =
+    olapGroupByState.tdsState.queryBuilderState.isFetchStructureTyped;
+  if (typedTds) {
+    olapGroupByState.windowColumns.forEach((c) =>
+      appendExtendColumnState(c, lambda),
+    );
+  } else {
+    olapGroupByState.windowColumns.forEach((c) =>
+      appendOLAPGroupByColumnState(c, lambda),
+    );
+  }
   return lambda;
 };

package/src/stores/fetch-structure/tds/window/operators/QueryBuilderTDS_WindowOperator.ts

@@ -25,7 +25,9 @@ export abstract class QueryBuilderTDS_WindowOperator implements Hashable {
 
   abstract get hashCode(): string;
 
-  abstract get pureFunc(): string;
+  abstract get pureFunc(): string | undefined;
+
+  abstract get relationFunc(): string | undefined;
 
   abstract isCompatibleWithType(type: Type | undefined): boolean;
 

package/src/stores/fetch-structure/tds/window/operators/QueryBuilderTDS_WindowOperator_Average.ts

@@ -32,6 +32,10 @@ export class QueryBuilderTDS_WindowOperator_Average extends QueryBuilderTDS_Wind
     return QUERY_BUILDER_SUPPORTED_FUNCTIONS.AVERAGE;
   }
 
+  get relationFunc(): string | undefined {
+    return QUERY_BUILDER_SUPPORTED_FUNCTIONS.AVERAGE;
+  }
+
   get hashCode(): string {
     return hashArray([
       QUERY_BUILDER_STATE_HASH_STRUCTURE.TDS_WINDOW_OPERATOR_AVERAGE,

package/src/stores/fetch-structure/tds/window/operators/QueryBuilderTDS_WindowOperator_Count.ts

@@ -32,6 +32,10 @@ export class QueryBuilderTDS_WindowOperator_Count extends QueryBuilderTDS_Window
     return QUERY_BUILDER_SUPPORTED_FUNCTIONS.COUNT;
   }
 
+  get relationFunc(): string | undefined {
+    return QUERY_BUILDER_SUPPORTED_FUNCTIONS.COUNT;
+  }
+
   get hashCode(): string {
     return hashArray([
       QUERY_BUILDER_STATE_HASH_STRUCTURE.TDS_WINDOW_OPERATOR_COUNT,

package/src/stores/fetch-structure/tds/window/operators/QueryBuilderTDS_WindowOperator_Max.ts

@@ -32,6 +32,10 @@ export class QueryBuilderTDS_WindowOperator_Max extends QueryBuilderTDS_WindowOp
     return QUERY_BUILDER_SUPPORTED_FUNCTIONS.MAX;
   }
 
+  get relationFunc(): string | undefined {
+    return QUERY_BUILDER_SUPPORTED_FUNCTIONS.MAX;
+  }
+
   get hashCode(): string {
     return hashArray([
       QUERY_BUILDER_STATE_HASH_STRUCTURE.TDS_WINDOW_OPERATOR_MAX,

package/src/stores/fetch-structure/tds/window/operators/QueryBuilderTDS_WindowOperator_Min.ts

@@ -32,6 +32,10 @@ export class QueryBuilderTDS_WindowOperator_Min extends QueryBuilderTDS_WindowOp
     return QUERY_BUILDER_SUPPORTED_FUNCTIONS.MIN;
   }
 
+  get relationFunc(): string | undefined {
+    return QUERY_BUILDER_SUPPORTED_FUNCTIONS.MIN;
+  }
+
   get hashCode(): string {
     return hashArray([
       QUERY_BUILDER_STATE_HASH_STRUCTURE.TDS_WINDOW_OPERATOR_MIN,

package/src/stores/fetch-structure/tds/window/operators/QueryBuilderTDS_WindowOperator_PercentRank.ts

@@ -0,0 +1,57 @@
+/**
+ * Copyright (c) 2026-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 { PRIMITIVE_TYPE, type Type } from '@finos/legend-graph';
+import { QueryBuilderTDS_WindowOperator } from './QueryBuilderTDS_WindowOperator.js';
+import { hashArray } from '@finos/legend-shared';
+import { QUERY_BUILDER_STATE_HASH_STRUCTURE } from '../../../../QueryBuilderStateHashUtils.js';
+import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../../../graph/QueryBuilderMetaModelConst.js';
+
+export class QueryBuilderTDS_WindowRankOperator_PercentRank extends QueryBuilderTDS_WindowOperator {
+  override getLabel(): string {
+    return 'percent rank';
+  }
+  override get pureFunc(): string | undefined {
+    // percentRank() is only supported for typed TDS
+    return undefined;
+  }
+  override get relationFunc(): string | undefined {
+    return QUERY_BUILDER_SUPPORTED_FUNCTIONS.RELATION_PERCENT_RANK;
+  }
+  override get hashCode(): string {
+    return hashArray([
+      QUERY_BUILDER_STATE_HASH_STRUCTURE.TDS_WINDOW_OPERATOR_PERCENT_RANK,
+    ]);
+  }
+  override isCompatibleWithType(type: Type | undefined): boolean {
+    if (type) {
+      return (
+        [
+          PRIMITIVE_TYPE.STRING,
+          PRIMITIVE_TYPE.BOOLEAN,
+          PRIMITIVE_TYPE.NUMBER,
+          PRIMITIVE_TYPE.INTEGER,
+          PRIMITIVE_TYPE.DECIMAL,
+          PRIMITIVE_TYPE.FLOAT,
+          PRIMITIVE_TYPE.DATE,
+          PRIMITIVE_TYPE.STRICTDATE,
+          PRIMITIVE_TYPE.DATETIME,
+        ] as string[]
+      ).includes(type.path);
+    }
+    return true;
+  }
+}

package/src/stores/fetch-structure/tds/window/operators/QueryBuilderTDS_WindowOperator_Sum.ts

@@ -32,6 +32,10 @@ export class QueryBuilderTDS_WindowOperator_Sum extends QueryBuilderTDS_WindowOp
     return QUERY_BUILDER_SUPPORTED_FUNCTIONS.SUM;
   }
 
+  get relationFunc(): string | undefined {
+    return QUERY_BUILDER_SUPPORTED_FUNCTIONS.SUM;
+  }
+
   get hashCode(): string {
     return hashArray([
       QUERY_BUILDER_STATE_HASH_STRUCTURE.TDS_WINDOW_OPERATOR_SUM,

package/src/stores/fetch-structure/tds/window/operators/QueryBuilderTDS_WindowRankOperator_AverageRank.ts

@@ -29,6 +29,11 @@ export class QueryBuilderTDS_WindowRankOperator_AverageRank extends QueryBuilder
     return QUERY_BUILDER_SUPPORTED_FUNCTIONS.OLAP_AVERAGE_RANK;
   }
 
+  get relationFunc(): string | undefined {
+    //averageRank not supported for typed TDS
+    return undefined;
+  }
+
   get hashCode(): string {
     return hashArray([
       QUERY_BUILDER_STATE_HASH_STRUCTURE.TDS_WINDOW_OPERATOR_DENSE_RANK,

package/src/stores/fetch-structure/tds/window/operators/QueryBuilderTDS_WindowRankOperator_DenseRank.ts

@@ -29,6 +29,10 @@ export class QueryBuilderTDS_WindowRankOperator_DenseRank extends QueryBuilderTD
     return QUERY_BUILDER_SUPPORTED_FUNCTIONS.OLAP_DENSE_RANK;
   }
 
+  get relationFunc(): string | undefined {
+    return QUERY_BUILDER_SUPPORTED_FUNCTIONS.RELATION_DENSE_RANK;
+  }
+
   get hashCode(): string {
     return hashArray([
       QUERY_BUILDER_STATE_HASH_STRUCTURE.TDS_WINDOW_OPERATOR_DENSE_RANK,

package/src/stores/fetch-structure/tds/window/operators/QueryBuilderTDS_WindowRankOperator_Rank.ts

@@ -29,6 +29,10 @@ export class QueryBuilderTDS_WindowRankOperator_Rank extends QueryBuilderTDS_Win
     return QUERY_BUILDER_SUPPORTED_FUNCTIONS.OLAP_RANK;
   }
 
+  get relationFunc(): string | undefined {
+    return QUERY_BUILDER_SUPPORTED_FUNCTIONS.RELATION_RANK;
+  }
+
   get hashCode(): string {
     return hashArray([
       QUERY_BUILDER_STATE_HASH_STRUCTURE.TDS_WINDOW_OPERATOR_RANK,

package/src/stores/fetch-structure/tds/window/operators/QueryBuilderTDS_WindowRankOperator_RowNumber.ts

@@ -29,6 +29,10 @@ export class QueryBuilderTDS_WindowRankOperator_RowNumber extends QueryBuilderTD
     return QUERY_BUILDER_SUPPORTED_FUNCTIONS.OLAP_ROW_NUMBER;
   }
 
+  get relationFunc(): string | undefined {
+    return QUERY_BUILDER_SUPPORTED_FUNCTIONS.RELATION_ROW_NUMBER;
+  }
+
   get hashCode(): string {
     return hashArray([
       QUERY_BUILDER_STATE_HASH_STRUCTURE.TDS_WINDOW_OPERATOR_ROW_NUMBER,

package/src/stores/filter/QueryBuilderFilterValueSpecificationBuilder.ts

@@ -156,7 +156,7 @@ export const buildFilterConditionExpression = (
     } else if (clauses.length === 1) {
       const lambdaFunctionInstanceValue =
         buildGenericLambdaFunctionInstanceValue(
-          node.lambdaParameterName ?? DEFAULT_LAMBDA_VARIABLE_NAME,
+          [node.lambdaParameterName ?? DEFAULT_LAMBDA_VARIABLE_NAME],
           clauses,
           filterState.queryBuilderState.graphManagerState.graph,
         );
@@ -175,7 +175,7 @@ export const buildFilterConditionExpression = (
     );
     simp.parametersValues = parametersValues;
     const lambdaFunctionInstanceValue = buildGenericLambdaFunctionInstanceValue(
-      node.lambdaParameterName ?? DEFAULT_LAMBDA_VARIABLE_NAME,
+      [node.lambdaParameterName ?? DEFAULT_LAMBDA_VARIABLE_NAME],
       [simp],
       filterState.queryBuilderState.graphManagerState.graph,
     );
@@ -209,7 +209,7 @@ export const buildFilterExpression = (
   // param [1]
   filterExpression.parametersValues.push(
     buildGenericLambdaFunctionInstanceValue(
-      filterState.lambdaParameterName,
+      [filterState.lambdaParameterName],
       filterConditionExpressions,
       filterState.queryBuilderState.graphManagerState.graph,
     ),

package/src/stores/milestoning/QueryBuilderMilestoningState.ts

@@ -163,7 +163,7 @@ export class QueryBuilderMilestoningState implements Hashable {
         } else if (node instanceof QueryBuilderFilterTreeExistsNodeData) {
           if (
             node.propertyExpressionState.derivedPropertyExpressionStates[0] &&
-            this.queryBuilderState.class?._generatedMilestonedProperties.includes(
+            this.queryBuilderState.sourceClass?._generatedMilestonedProperties.includes(
               node.propertyExpressionState.derivedPropertyExpressionStates[0]
                 .derivedProperty,
             )
@@ -192,7 +192,7 @@ export class QueryBuilderMilestoningState implements Hashable {
   }
 
   get isCurrentClassMilestoned(): boolean {
-    const currentclass = this.queryBuilderState.class;
+    const currentclass = this.queryBuilderState.sourceClass;
     if (currentclass !== undefined) {
       const stereotype = getMilestoneTemporalStereotype(
         currentclass,
@@ -204,7 +204,7 @@ export class QueryBuilderMilestoningState implements Hashable {
   }
 
   get isCurrentClassSupportsVersionsInRange(): boolean {
-    const currentclass = this.queryBuilderState.class;
+    const currentclass = this.queryBuilderState.sourceClass;
     if (currentclass !== undefined) {
       const stereotype = getMilestoneTemporalStereotype(
         currentclass,
@@ -412,7 +412,7 @@ export class QueryBuilderMilestoningState implements Hashable {
   }
 
   updateMilestoningConfiguration(): void {
-    const currentclass = this.queryBuilderState.class;
+    const currentclass = this.queryBuilderState.sourceClass;
     if (currentclass !== undefined) {
       const stereotype = getMilestoneTemporalStereotype(
         currentclass,

package/src/stores/workflows/MappingQueryBuilderState.ts

@@ -92,10 +92,10 @@ export class MappingQueryBuilderState extends QueryBuilderState {
     );
     // if there is no chosen class or the chosen one is not compatible
     // with the mapping then pick a compatible class if possible
-    if (!this.class || !compatibleClasses.includes(this.class)) {
+    if (!this.sourceClass || !compatibleClasses.includes(this.sourceClass)) {
       const possibleNewClass = compatibleClasses[0];
       if (possibleNewClass) {
-        this.changeClass(possibleNewClass);
+        this.changeSourceElement(possibleNewClass);
       }
     }
   }

package/src/stores/workflows/ServiceQueryBuilderState.ts

@@ -169,10 +169,10 @@ export class ServiceQueryBuilderState extends QueryBuilderState {
       );
       // if there is no chosen class or the chosen one is not compatible
       // with the mapping then pick a compatible class if possible
-      if (!this.class || !compatibleClasses.includes(this.class)) {
+      if (!this.sourceClass || !compatibleClasses.includes(this.sourceClass)) {
         const possibleNewClass = compatibleClasses[0];
         if (possibleNewClass) {
-          this.changeClass(possibleNewClass);
+          this.changeSourceElement(possibleNewClass);
         }
       }
     }

package/src/stores/workflows/accessor/AccessorQueryBuilderHelper.ts

@@ -0,0 +1,51 @@
+/**
+ * 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 AccessorOwner,
+  type GraphManagerState,
+  type PackageableRuntime,
+  IngestDefinition,
+  Database,
+  DataProduct,
+  EngineRuntime,
+  LakehouseRuntime,
+} from '@finos/legend-graph';
+import { UnsupportedOperationError } from '@finos/legend-shared';
+
+export const getCompatibleRuntimesFromAccessorOwner = (
+  accessorOwner: AccessorOwner,
+  graphManagerState: GraphManagerState,
+): PackageableRuntime[] => {
+  if (accessorOwner instanceof DataProduct) {
+    throw new UnsupportedOperationError(
+      `DataProduct is not supported as an accessor owner`,
+    );
+  }
+  if (accessorOwner instanceof IngestDefinition) {
+    return graphManagerState.usableRuntimes.filter(
+      (runtime) => runtime.runtimeValue instanceof LakehouseRuntime,
+    );
+  } else if (accessorOwner instanceof Database) {
+    return graphManagerState.usableRuntimes.filter(
+      (runtime) =>
+        runtime.runtimeValue instanceof EngineRuntime &&
+        !(runtime.runtimeValue instanceof LakehouseRuntime) &&
+        runtime.runtimeValue.mappings.length === 0,
+    );
+  }
+  return [];
+};