@finos/legend-application-query 5.2.1 → 5.2.4

package/src/stores/{QueryBuilderOperatorsHelper.ts → QueryBuilderValueSpecificationHelper.ts}

@@ -15,19 +15,25 @@
  */
 
 import {
-  type PrimitiveType,
-  type Enumeration,
-  type Type,
   type PureModel,
   type ValueSpecification,
+  CORE_PURE_PATH,
+  FunctionType,
+  LambdaFunction,
+  LambdaFunctionInstanceValue,
   PRIMITIVE_TYPE,
-  extractElementNameFromPath,
-  matchFunctionName,
-  SimpleFunctionExpression,
   TYPICAL_MULTIPLICITY_TYPE,
+  VariableExpression,
+  DATE_FORMAT,
+  DATE_TIME_FORMAT,
+  matchFunctionName,
+  type Type,
   PrimitiveInstanceValue,
   EnumValueInstanceValue,
-  VariableExpression,
+  SimpleFunctionExpression,
+  type PrimitiveType,
+  type Enumeration,
+  extractElementNameFromPath,
   AbstractPropertyExpression,
   isSuperType,
 } from '@finos/legend-graph';
@@ -37,43 +43,9 @@ import {
   guaranteeType,
   UnsupportedOperationError,
 } from '@finos/legend-shared';
+import { format } from 'date-fns';
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../QueryBuilder_Const.js';
 
-export enum QUERY_BUILDER_GROUP_OPERATION {
-  AND = 'and',
-  OR = 'or',
-}
-
-export const fromGroupOperation = (
-  operation: QUERY_BUILDER_GROUP_OPERATION,
-): string => {
-  switch (operation) {
-    case QUERY_BUILDER_GROUP_OPERATION.AND:
-      return QUERY_BUILDER_SUPPORTED_FUNCTIONS.AND;
-    case QUERY_BUILDER_GROUP_OPERATION.OR:
-      return QUERY_BUILDER_SUPPORTED_FUNCTIONS.OR;
-    default:
-      throw new UnsupportedOperationError(
-        `Can't derive function name from group operation '${operation}'`,
-      );
-  }
-};
-
-export const toGroupOperation = (
-  functionName: string,
-): QUERY_BUILDER_GROUP_OPERATION => {
-  if (matchFunctionName(functionName, QUERY_BUILDER_SUPPORTED_FUNCTIONS.AND)) {
-    return QUERY_BUILDER_GROUP_OPERATION.AND;
-  } else if (
-    matchFunctionName(functionName, QUERY_BUILDER_SUPPORTED_FUNCTIONS.OR)
-  ) {
-    return QUERY_BUILDER_GROUP_OPERATION.OR;
-  }
-  throw new UnsupportedOperationError(
-    `Can't derive group operation from function name '${functionName}'`,
-  );
-};
-
 export const getNonCollectionValueSpecificationType = (
   valueSpecification: ValueSpecification,
 ): Type | undefined => {
@@ -191,9 +163,9 @@ export const isPropertyExpressionChainOptional = (
   return isOptional;
 };
 
-export const isTypeCompatibleWithConditionValueType = (
+export const isTypeCompatibleForAssignment = (
   type: Type | undefined,
-  conditionValueType: Type,
+  assignmentType: Type,
 ): boolean => {
   const NUMERIC_PRIMITIVE_TYPES = [
     PRIMITIVE_TYPE.NUMBER,
@@ -214,13 +186,60 @@ export const isTypeCompatibleWithConditionValueType = (
     // Numeric value is handled loosely because of autoboxing
     // e.g. LHS (integer) = RHS (float) is acceptable
     ((NUMERIC_PRIMITIVE_TYPES.includes(type.path) &&
-      NUMERIC_PRIMITIVE_TYPES.includes(conditionValueType.path)) ||
+      NUMERIC_PRIMITIVE_TYPES.includes(assignmentType.path)) ||
       // Date value is handled loosely as well if the LHS is of type DateTime
       // This is because we would simulate auto-boxing for date by altering the
       // Pure function used for the operation
       // e.g. LHS(DateTime) = RHS(Date) -> we use isOnDay() instead of is()
       DATE_PRIMITIVE_TYPES.includes(type.path) ||
-      type === conditionValueType ||
-      isSuperType(conditionValueType, type))
+      type === assignmentType ||
+      isSuperType(assignmentType, type))
+  );
+};
+
+export const generateDefaultValueForPrimitiveType = (
+  type: PRIMITIVE_TYPE,
+): unknown => {
+  switch (type) {
+    case PRIMITIVE_TYPE.STRING:
+      return '';
+    case PRIMITIVE_TYPE.BOOLEAN:
+      return false;
+    case PRIMITIVE_TYPE.NUMBER:
+    case PRIMITIVE_TYPE.DECIMAL:
+    case PRIMITIVE_TYPE.FLOAT:
+    case PRIMITIVE_TYPE.INTEGER:
+      return 0;
+    case PRIMITIVE_TYPE.DATE:
+    case PRIMITIVE_TYPE.STRICTDATE:
+      return format(new Date(Date.now()), DATE_FORMAT);
+    case PRIMITIVE_TYPE.DATETIME:
+      return format(new Date(Date.now()), DATE_TIME_FORMAT);
+    default:
+      throw new UnsupportedOperationError(
+        `Can't generate default value for primitive type '${type}'`,
+      );
+  }
+};
+
+export const buildGenericLambdaFunctionInstanceValue = (
+  lambdaParameterName: string,
+  lambdaBodyExpressions: ValueSpecification[],
+  graph: PureModel,
+): LambdaFunctionInstanceValue => {
+  const multiplicityOne = graph.getTypicalMultiplicity(
+    TYPICAL_MULTIPLICITY_TYPE.ONE,
+  );
+  const typeAny = graph.getType(CORE_PURE_PATH.ANY);
+  const functionInstanceValue = new LambdaFunctionInstanceValue(
+    multiplicityOne,
+  );
+  const functionType = new FunctionType(typeAny, multiplicityOne);
+  functionType.parameters.push(
+    new VariableExpression(lambdaParameterName, multiplicityOne),
   );
+  const lambdaFunction = new LambdaFunction(functionType);
+  lambdaFunction.expressionSequence = lambdaBodyExpressions;
+  functionInstanceValue.values.push(lambdaFunction);
+  return functionInstanceValue;
 };

package/src/stores/{QueryBuilderLambdaProcessor.ts → QueryBuilderValueSpecificationProcessor.ts}

@@ -31,13 +31,13 @@ import type { QueryBuilderState } from './QueryBuilderState.js';
 import {
   COLUMN_SORT_TYPE,
   SortColumnState,
-} from './QueryResultSetModifierState.js';
+} from './fetch-structure/projection/QueryResultSetModifierState.js';
 import {
   type QueryBuilderFilterState,
   QueryBuilderFilterTreeGroupNodeData,
   QueryBuilderFilterTreeConditionNodeData,
-} from './QueryBuilderFilterState.js';
-import { FETCH_STRUCTURE_MODE } from './QueryBuilderFetchStructureState.js';
+} from './filter/QueryBuilderFilterState.js';
+import { FETCH_STRUCTURE_MODE } from './fetch-structure/QueryBuilderFetchStructureState.js';
 import {
   type AlloySerializationConfigInstanceValue,
   type EnumValueInstanceValue,
@@ -76,13 +76,13 @@ import {
   type QueryBuilderProjectionColumnState,
   QueryBuilderDerivationProjectionColumnState,
   QueryBuilderSimpleProjectionColumnState,
-} from './QueryBuilderProjectionState.js';
-import type { QueryBuilderAggregationState } from './QueryBuilderAggregationState.js';
-import { toGroupOperation } from './QueryBuilderOperatorsHelper.js';
-import { processPostFilterLambda } from './QueryBuilderPostFilterProcessor.js';
+} from './fetch-structure/projection/QueryBuilderProjectionColumnState.js';
+import type { QueryBuilderAggregationState } from './fetch-structure/projection/aggregation/QueryBuilderAggregationState.js';
+import { processPostFilterLambda } from './fetch-structure/projection/post-filter/QueryBuilderPostFilterValueSpecificationProcessor.js';
 import { getDerivedPropertyMilestoningSteoreotype } from './QueryBuilderPropertyEditorState.js';
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../QueryBuilder_Const.js';
 import { LambdaParameterState } from '@finos/legend-application';
+import { toGroupOperation } from './QueryBuilderGroupOperationHelper.js';
 
 const getNullableStringValueFromValueSpec = (
   valueSpec: ValueSpecification,
@@ -613,7 +613,9 @@ export class QueryBuilderLambdaProcessor
           ),
           `Can't process post-filter expression: only supports ${QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_FILTER}() immediately following TDS project()/groupBy() (got '${functionName}')`,
         );
-        const postFilterState = this.queryBuilderState.postFilterState;
+        const postFilterState =
+          this.queryBuilderState.fetchStructureState.projectionState
+            .postFilterState;
         const postFilterLambda = valueSpecification.parametersValues[1];
         assertType(
           postFilterLambda,
@@ -621,7 +623,9 @@ export class QueryBuilderLambdaProcessor
           `Can't process post-filter expression: expects argument #1 to be a lambda function`,
         );
         processPostFilterLambda(postFilterLambda, postFilterState);
-        this.queryBuilderState.setShowPostFilterPanel(true);
+        this.queryBuilderState.fetchStructureState.projectionState.setShowPostFilterPanel(
+          true,
+        );
         postFilterState.simplifyTree();
         return;
       } else {
@@ -733,7 +737,9 @@ export class QueryBuilderLambdaProcessor
       const takeValue = getNullableNumberValueFromValueSpec(
         guaranteeNonNullable(valueSpecification.parametersValues[1]),
       );
-      this.queryBuilderState.resultSetModifierState.setLimit(takeValue);
+      this.queryBuilderState.fetchStructureState.projectionState.resultSetModifierState.setLimit(
+        takeValue,
+      );
 
       return;
     } else if (
@@ -769,7 +775,8 @@ export class QueryBuilderLambdaProcessor
         `Can't process distinct() expression: only support distinct() in TDS expression`,
       );
 
-      this.queryBuilderState.resultSetModifierState.distinct = true;
+      this.queryBuilderState.fetchStructureState.projectionState.resultSetModifierState.distinct =
+        true;
 
       return;
     } else if (
@@ -850,7 +857,6 @@ export class QueryBuilderLambdaProcessor
         );
       if (queryBuilderProjectionColumnState) {
         const sortColumnState = new SortColumnState(
-          this.queryBuilderState,
           queryBuilderProjectionColumnState,
         );
         sortColumnState.sortType = matchFunctionName(
@@ -859,7 +865,7 @@ export class QueryBuilderLambdaProcessor
         )
           ? COLUMN_SORT_TYPE.ASC
           : COLUMN_SORT_TYPE.DESC;
-        this.queryBuilderState.resultSetModifierState.addSortColumn(
+        this.queryBuilderState.fetchStructureState.projectionState.resultSetModifierState.addSortColumn(
           sortColumnState,
         );
       }
@@ -1223,6 +1229,7 @@ export const processQueryParameters = (
     const parameterState = new LambdaParameterState(
       parameter,
       queryBuilderState.observableContext,
+      queryBuilderState.graphManagerState.graph,
     );
     parameterState.mockParameterValue();
     queryParameterState.addParameter(parameterState);

package/src/stores/{QueryBuilderExplorerState.ts → explorer/QueryBuilderExplorerState.ts}

@@ -21,6 +21,8 @@ import {
   ActionState,
   assertErrorThrown,
   type GeneratorFn,
+  assertType,
+  UnsupportedOperationError,
 } from '@finos/legend-shared';
 import {
   type AbstractProperty,
@@ -52,8 +54,11 @@ import {
   DerivedProperty,
   Property,
   Association,
+  PRIMITIVE_TYPE,
+  TdsExecutionResult,
+  type ExecutionResult,
 } from '@finos/legend-graph';
-import type { QueryBuilderState } from './QueryBuilderState.js';
+import type { QueryBuilderState } from '../QueryBuilderState.js';
 import {
   action,
   flow,
@@ -65,8 +70,12 @@ import {
 import {
   DEFAULT_LAMBDA_VARIABLE_NAME,
   QUERY_BUILDER_SUPPORTED_FUNCTIONS,
-} from '../QueryBuilder_Const.js';
-import type { QueryBuilderPreviewData } from './QueryBuilderPreviewDataHelper.js';
+} from '../../QueryBuilder_Const.js';
+import {
+  buildNonNumericPreviewDataQuery,
+  buildNumericPreviewDataQuery,
+  type QueryBuilderPreviewData,
+} from '../QueryBuilderPreviewDataHelper.js';
 import { QueryBuilderPropertySearchPanelState } from './QueryBuilderPropertySearchPanelState.js';
 
 export enum QUERY_BUILDER_EXPLORER_TREE_DND_TYPE {
@@ -310,6 +319,11 @@ const generateSubtypeNodeMappingData = (
           (mappedProperty[0] as EntityMappedProperty).entityPath,
         ),
       };
+    } else if (parentMappingData.mappedEntity.path === subclass.path) {
+      return {
+        mapped: true,
+        mappedEntity: parentMappingData.mappedEntity,
+      };
     }
   }
   return { mapped: false };
@@ -536,6 +550,7 @@ export class QueryBuilderExplorerState {
       refreshTreeData: action,
       setHumanizePropertyName: action,
       setShowUnmappedProperties: action,
+      previewData: flow,
       analyzeMappingModelCoverage: flow,
     });
 
@@ -606,4 +621,129 @@ export class QueryBuilderExplorerState {
       this.queryBuilderState.explorerState.mappingModelCoverageAnalysisState.pass();
     }
   }
+
+  *previewData(
+    node: QueryBuilderExplorerTreePropertyNodeData,
+  ): GeneratorFn<void> {
+    const runtime = this.queryBuilderState.querySetupState.runtimeValue;
+    if (!runtime) {
+      this.queryBuilderState.applicationStore.notifyWarning(
+        `Can't preview data for property '${node.property.name}': runtime is not specified`,
+      );
+      return;
+    }
+    if (
+      !node.mappingData.mapped ||
+      !this.queryBuilderState.querySetupState._class ||
+      !this.queryBuilderState.querySetupState.mapping
+    ) {
+      return;
+    }
+    if (
+      this.queryBuilderState.explorerState.previewDataState
+        .isGeneratingPreviewData
+    ) {
+      this.queryBuilderState.applicationStore.notifyWarning(
+        `Can't preview data for property '${node.property.name}': another preview request is being executed`,
+      );
+      return;
+    }
+    this.queryBuilderState.explorerState.previewDataState.setPropertyName(
+      node.property.name,
+    );
+    this.queryBuilderState.explorerState.previewDataState.setIsGeneratingPreviewData(
+      true,
+    );
+    const propertyExpression = buildPropertyExpressionFromExplorerTreeNodeData(
+      this.queryBuilderState.explorerState.nonNullableTreeData,
+      node,
+      this.queryBuilderState.graphManagerState.graph,
+      this.queryBuilderState.explorerState.propertySearchPanelState
+        .allMappedPropertyNodes,
+    );
+    const propertyType = node.property.genericType.value.rawType;
+    try {
+      switch (propertyType.path) {
+        case PRIMITIVE_TYPE.NUMBER:
+        case PRIMITIVE_TYPE.INTEGER:
+        case PRIMITIVE_TYPE.DECIMAL:
+        case PRIMITIVE_TYPE.FLOAT: {
+          const previewResult =
+            (yield this.queryBuilderState.graphManagerState.graphManager.executeMapping(
+              buildNumericPreviewDataQuery(
+                this.queryBuilderState,
+                propertyExpression,
+              ),
+              this.queryBuilderState.querySetupState.mapping,
+              runtime,
+              this.queryBuilderState.graphManagerState.graph,
+            )) as ExecutionResult;
+          assertType(
+            previewResult,
+            TdsExecutionResult,
+            `Unexpected preview data format`,
+          );
+          const previewResultData =
+            previewResult.result as QueryBuilderPreviewData;
+          // transpose the result
+          const transposedPreviewResultData = {
+            columns: ['Aggregation', 'Value'],
+            rows: previewResultData.columns.map((column, idx) => ({
+              values: [
+                column,
+                guaranteeNonNullable(previewResultData.rows[0]).values[
+                  idx
+                ] as string,
+              ],
+            })),
+          };
+          this.queryBuilderState.explorerState.previewDataState.setPreviewData(
+            transposedPreviewResultData,
+          );
+          break;
+        }
+        case PRIMITIVE_TYPE.BOOLEAN:
+        case PRIMITIVE_TYPE.STRING:
+        case PRIMITIVE_TYPE.DATE:
+        case PRIMITIVE_TYPE.STRICTDATE:
+        case PRIMITIVE_TYPE.DATETIME: {
+          const previewResult =
+            (yield this.queryBuilderState.graphManagerState.graphManager.executeMapping(
+              buildNonNumericPreviewDataQuery(
+                this.queryBuilderState,
+                propertyExpression,
+              ),
+              this.queryBuilderState.querySetupState.mapping,
+              runtime,
+              this.queryBuilderState.graphManagerState.graph,
+            )) as ExecutionResult;
+          assertType(
+            previewResult,
+            TdsExecutionResult,
+            `Unexpected preview data format`,
+          );
+          this.queryBuilderState.explorerState.previewDataState.setPreviewData(
+            previewResult.result as QueryBuilderPreviewData,
+          );
+          break;
+        }
+        default:
+          throw new UnsupportedOperationError(
+            `No preview support for property of type '${propertyType.path}'`,
+          );
+      }
+    } catch (error) {
+      assertErrorThrown(error);
+      this.queryBuilderState.applicationStore.notifyWarning(
+        `Can't preview data for property '${node.property.name}'. Error: ${error.message}`,
+      );
+      this.queryBuilderState.explorerState.previewDataState.setPreviewData(
+        undefined,
+      );
+    } finally {
+      this.queryBuilderState.explorerState.previewDataState.setIsGeneratingPreviewData(
+        false,
+      );
+    }
+  }
 }

package/src/stores/{QueryBuilderPropertySearchPanelState.ts → explorer/QueryBuilderPropertySearchPanelState.ts}

@@ -32,7 +32,7 @@ import {
   QUERY_BUILDER_PROPERTY_SEARCH_MAX_DEPTH,
   QUERY_BUILDER_PROPERTY_SEARCH_RESULTS_LIMIT,
   QUERY_BUILDER_PROPERTY_SEARCH_TYPE,
-} from '../QueryBuilder_Const.js';
+} from '../../QueryBuilder_Const.js';
 import {
   getQueryBuilderPropertyNodeData,
   getQueryBuilderSubTypeNodeData,
@@ -40,7 +40,7 @@ import {
   QueryBuilderExplorerTreePropertyNodeData,
   QueryBuilderExplorerTreeSubTypeNodeData,
 } from './QueryBuilderExplorerState.js';
-import type { QueryBuilderState } from './QueryBuilderState.js';
+import type { QueryBuilderState } from '../QueryBuilderState.js';
 
 export class QueryBuilderPropertySearchPanelState {
   queryBuilderState: QueryBuilderState;

package/src/stores/{QueryFunctionsExplorerState.ts → explorer/QueryFunctionsExplorerState.ts}

@@ -28,7 +28,7 @@ import {
   uuid,
 } from '@finos/legend-shared';
 import { action, makeObservable, observable } from 'mobx';
-import type { QueryBuilderState } from './QueryBuilderState.js';
+import type { QueryBuilderState } from '../QueryBuilderState.js';
 import type { TreeNodeData, TreeData } from '@finos/legend-art';
 
 export const QUERY_BUILDER_FUNCTION_DND_TYPE = 'QUERY_BUILDER_FUNCTION';

package/src/stores/fetch-structure/QueryBuilderFetchStructureImplementationState.ts

@@ -0,0 +1,34 @@
+/**
+ * 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 { QueryBuilderState } from '../QueryBuilderState.js';
+import type { QueryBuilderFetchStructureState } from './QueryBuilderFetchStructureState.js';
+
+export abstract class QueryBuilderFetchStructureImplementationState {
+  queryBuilderState: QueryBuilderState;
+  fetchStructureState: QueryBuilderFetchStructureState;
+
+  constructor(
+    queryBuilderState: QueryBuilderState,
+    fetchStructureState: QueryBuilderFetchStructureState,
+  ) {
+    this.queryBuilderState = queryBuilderState;
+    this.fetchStructureState = fetchStructureState;
+  }
+
+  // abstract addProperty(node: QueryBuilderExplorerTreePropertyNodeData): void;
+  // abstract addChildrenProperties(node: QueryBuilderExplorerTreePropertyNodeData): void;
+}

package/src/stores/fetch-structure/QueryBuilderFetchStructureState.ts

@@ -0,0 +1,173 @@
+/**
+ * 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 { action, makeAutoObservable } from 'mobx';
+import type { QueryBuilderState } from '../QueryBuilderState.js';
+import { QueryBuilderGraphFetchTreeState } from './graph-fetch/QueryBuilderGraphFetchTreeState.js';
+import { QueryBuilderProjectionState } from './projection/QueryBuilderProjectionState.js';
+import {
+  buildPropertyExpressionFromExplorerTreeNodeData,
+  type QueryBuilderExplorerTreeNodeData,
+  QueryBuilderExplorerTreePropertyNodeData,
+} from '../explorer/QueryBuilderExplorerState.js';
+import { Class } from '@finos/legend-graph';
+import { filterByType } from '@finos/legend-shared';
+import { addQueryBuilderPropertyNode } from './graph-fetch/QueryBuilderGraphFetchTreeUtil.js';
+import { QueryBuilderSimpleProjectionColumnState } from './projection/QueryBuilderProjectionColumnState.js';
+
+export enum FETCH_STRUCTURE_MODE {
+  PROJECTION = 'PROJECTION',
+  GRAPH_FETCH = 'GRAPH_FETCH',
+}
+
+export class QueryBuilderFetchStructureState {
+  queryBuilderState: QueryBuilderState;
+  /**
+   * TODO: refactor this so we could reduce this to
+   * `implementationState: QueryBuilderFetchStructureImplementationState`
+   * so we don't have graph fetch and projection at the same time
+   *
+   * TODO?: perhaps it would eventually make sense to default to
+   * graph-fetch since `getAll()` naturally works for graph-fetch case
+   * and graph-fetch allows somewhat an empty tree
+   */
+  fetchStructureMode = FETCH_STRUCTURE_MODE.PROJECTION;
+  projectionState: QueryBuilderProjectionState;
+  graphFetchTreeState: QueryBuilderGraphFetchTreeState;
+
+  constructor(queryBuilderState: QueryBuilderState) {
+    makeAutoObservable(this, {
+      queryBuilderState: false,
+      setFetchStructureMode: action,
+    });
+
+    this.queryBuilderState = queryBuilderState;
+    // TODO: we probably should modularize this a bit better
+    // See https://github.com/finos/legend-studio/issues/731
+    this.projectionState = new QueryBuilderProjectionState(
+      queryBuilderState,
+      this,
+    );
+    this.graphFetchTreeState = new QueryBuilderGraphFetchTreeState(
+      queryBuilderState,
+      this,
+    );
+  }
+
+  setFetchStructureMode(val: FETCH_STRUCTURE_MODE): void {
+    this.fetchStructureMode = val;
+  }
+
+  fetchProperty(node: QueryBuilderExplorerTreeNodeData): void {
+    if (
+      node instanceof QueryBuilderExplorerTreePropertyNodeData &&
+      !(node.type instanceof Class)
+    ) {
+      switch (this.fetchStructureMode) {
+        case FETCH_STRUCTURE_MODE.GRAPH_FETCH: {
+          this.graphFetchTreeState.addProperty(node);
+          return;
+        }
+        case FETCH_STRUCTURE_MODE.PROJECTION: {
+          this.projectionState.addColumn(
+            new QueryBuilderSimpleProjectionColumnState(
+              this.projectionState,
+              buildPropertyExpressionFromExplorerTreeNodeData(
+                this.queryBuilderState.explorerState.nonNullableTreeData,
+                node,
+                this.queryBuilderState.graphManagerState.graph,
+                this.queryBuilderState.explorerState.propertySearchPanelState
+                  .allMappedPropertyNodes,
+              ),
+              this.queryBuilderState.explorerState.humanizePropertyName,
+            ),
+          );
+          return;
+        }
+        default:
+          return;
+      }
+    }
+  }
+
+  fetchNodeChildrenProperties(node: QueryBuilderExplorerTreeNodeData): void {
+    if (node.type instanceof Class) {
+      // NOTE: here we require the node to already been expanded so the child nodes are generated
+      // we don't allow adding unopened node. Maybe if it helps, we can show a warning.
+      const nodesToAdd = node.childrenIds
+        .map((childId) =>
+          this.queryBuilderState.explorerState.nonNullableTreeData.nodes.get(
+            childId,
+          ),
+        )
+        .filter(filterByType(QueryBuilderExplorerTreePropertyNodeData))
+        .filter(
+          (childNode) =>
+            !(childNode.type instanceof Class) && childNode.mappingData.mapped,
+        );
+
+      switch (this.fetchStructureMode) {
+        case FETCH_STRUCTURE_MODE.GRAPH_FETCH: {
+          const graphFetchTreeData = this.graphFetchTreeState.treeData;
+          if (graphFetchTreeData) {
+            nodesToAdd.forEach((nodeToAdd) =>
+              addQueryBuilderPropertyNode(
+                graphFetchTreeData,
+                this.queryBuilderState.explorerState.nonNullableTreeData,
+                nodeToAdd,
+                this.queryBuilderState,
+              ),
+            );
+            this.graphFetchTreeState.setGraphFetchTree({
+              ...graphFetchTreeData,
+            });
+          }
+          return;
+        }
+        case FETCH_STRUCTURE_MODE.PROJECTION: {
+          nodesToAdd.forEach((nodeToAdd) => {
+            this.projectionState.addColumn(
+              new QueryBuilderSimpleProjectionColumnState(
+                this.projectionState,
+                buildPropertyExpressionFromExplorerTreeNodeData(
+                  this.queryBuilderState.explorerState.nonNullableTreeData,
+                  nodeToAdd,
+                  this.queryBuilderState.graphManagerState.graph,
+                  this.queryBuilderState.explorerState.propertySearchPanelState
+                    .allMappedPropertyNodes,
+                ),
+                this.queryBuilderState.explorerState.humanizePropertyName,
+              ),
+            );
+          });
+          return;
+        }
+        default:
+          return;
+      }
+    }
+  }
+
+  get validationIssues(): string[] | undefined {
+    switch (this.fetchStructureMode) {
+      case FETCH_STRUCTURE_MODE.PROJECTION:
+        return this.projectionState.validationIssues;
+      case FETCH_STRUCTURE_MODE.GRAPH_FETCH:
+      default:
+        return undefined;
+    }
+  }
+}