@finos/legend-application-query 5.2.5 → 5.2.8

package/src/stores/QueryBuilderValueSpecificationBuilderHelper.ts

@@ -0,0 +1,254 @@
+/**
+ * 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 {
+  functionExpression_setParametersValues,
+  propertyExpression_setParametersValue,
+} from '@finos/legend-application';
+import {
+  AbstractPropertyExpression,
+  Class,
+  DerivedProperty,
+  getMilestoneTemporalStereotype,
+  INTERNAL__PropagatedValue,
+  matchFunctionName,
+  MILESTONING_STEREOTYPE,
+  SimpleFunctionExpression,
+  TYPICAL_MULTIPLICITY_TYPE,
+  type ValueSpecification,
+} from '@finos/legend-graph';
+import {
+  getNullableFirstElement,
+  guaranteeNonNullable,
+  guaranteeType,
+} from '@finos/legend-shared';
+import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../QueryBuilder_Const.js';
+import { getDerivedPropertyMilestoningSteoreotype } from './QueryBuilderPropertyEditorState.js';
+import type { QueryBuilderState } from './QueryBuilderState.js';
+
+/**
+ * Checks if the provided property expression match the criteria for default
+ * date propagation so we know whether we need to fill in values for the parameter
+ * or just propgate values from the parent's expression
+ *
+ * NOTE: this takes date propgation into account. See the table below for all
+ * the combination:
+ *
+ *             | [source] |          |          |          |          |
+ * ----------------------------------------------------------------------
+ *   [target]  |          |   NONE   |  PR_TMP  |  BI_TMP  |  BU_TMP  |
+ * ----------------------------------------------------------------------
+ *             |   NONE   |   N.A.   |   PRD    | PRD,BUD  |    BUD   |
+ * ----------------------------------------------------------------------
+ *             |  PR_TMP  |   N.A.   |    X     | PRD,BUD  |    BUD   |
+ * ----------------------------------------------------------------------
+ *             |  BI_TMP  |   N.A.   |    X     |    X     |    X     |
+ * ----------------------------------------------------------------------
+ *             |  BU_TMP  |   N.A.   |   PRD    | PRD,BUD  |    X     |
+ * ----------------------------------------------------------------------
+ *
+ * Annotations:
+ *
+ * [source]: source temporal type
+ * [target]: target temporal type
+ *
+ * PR_TMP  : processing temporal
+ * BI_TMP  : bitemporal
+ * BU_TMP  : business temporal
+ *
+ * X       : no default date propagated
+ * PRD     : default processing date is propagated
+ * BUD     : default business date is propgated
+ */
+const isDefaultDatePropagationSupported = (
+  currentPropertyExpression: AbstractPropertyExpression,
+  queryBuilderState: QueryBuilderState,
+  prevPropertyExpression?: AbstractPropertyExpression | undefined,
+  isDatePropagationNotSupported?: boolean,
+): boolean => {
+  if (isDatePropagationNotSupported) {
+    return false;
+  }
+  const property = currentPropertyExpression.func;
+  const graph = queryBuilderState.graphManagerState.graph;
+  // Default date propagation is not supported for current expression when the previous property expression is a derived property.
+  if (
+    prevPropertyExpression &&
+    prevPropertyExpression.func instanceof DerivedProperty &&
+    prevPropertyExpression.func._OWNER.derivedProperties.includes(
+      prevPropertyExpression.func,
+    )
+  ) {
+    return false;
+  }
+  // Default date propagation is not supported for current expression when the milestonedParameterValues of
+  // the previous property expression doesn't match with the global milestonedParameterValues
+  if (
+    prevPropertyExpression &&
+    prevPropertyExpression.func.genericType.value.rawType instanceof Class
+  ) {
+    const milestoningStereotype = getMilestoneTemporalStereotype(
+      prevPropertyExpression.func.genericType.value.rawType,
+      graph,
+    );
+    if (
+      milestoningStereotype &&
+      !prevPropertyExpression.parametersValues
+        .slice(1)
+        .every(
+          (parameterValue) =>
+            parameterValue instanceof INTERNAL__PropagatedValue,
+        )
+    ) {
+      return false;
+    }
+  }
+  if (property.genericType.value.rawType instanceof Class) {
+    // the stereotype of source class of current property expression.
+    const sourceStereotype =
+      property instanceof DerivedProperty
+        ? getDerivedPropertyMilestoningSteoreotype(property, graph)
+        : undefined;
+    // Default date propagation is always supported if the source is `bitemporal`
+    if (sourceStereotype === MILESTONING_STEREOTYPE.BITEMPORAL) {
+      return true;
+    }
+    // the stereotype (if exists) of the generic type of current property expression.
+    const targetStereotype = getMilestoneTemporalStereotype(
+      property.genericType.value.rawType,
+      graph,
+    );
+    // Default date propagation is supported when stereotype of both source and target matches
+    if (sourceStereotype && targetStereotype) {
+      return sourceStereotype === targetStereotype;
+    }
+  }
+  return false;
+};
+
+export const buildPropertyExpressionChain = (
+  propertyExpression: AbstractPropertyExpression,
+  queryBuilderState: QueryBuilderState,
+  isDatePropagationNotSupported?: boolean,
+): ValueSpecification => {
+  const graph = queryBuilderState.graphManagerState.graph;
+  const newPropertyExpression = new AbstractPropertyExpression(
+    '',
+    graph.getTypicalMultiplicity(TYPICAL_MULTIPLICITY_TYPE.ONE),
+  );
+  newPropertyExpression.func = propertyExpression.func;
+  newPropertyExpression.parametersValues = propertyExpression.parametersValues;
+
+  let nextExpression: ValueSpecification | undefined;
+  let currentExpression: ValueSpecification | undefined = newPropertyExpression;
+  while (currentExpression instanceof AbstractPropertyExpression) {
+    nextExpression = getNullableFirstElement(
+      currentExpression.parametersValues,
+    );
+    if (nextExpression instanceof AbstractPropertyExpression) {
+      const parameterValue = new AbstractPropertyExpression(
+        '',
+        graph.getTypicalMultiplicity(TYPICAL_MULTIPLICITY_TYPE.ONE),
+      );
+      parameterValue.func = nextExpression.func;
+      parameterValue.parametersValues = nextExpression.parametersValues;
+      nextExpression = parameterValue;
+      currentExpression.parametersValues[0] = parameterValue;
+    }
+    if (currentExpression.func instanceof DerivedProperty) {
+      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 (
+            isDefaultDatePropagationSupported(
+              guaranteeType(currentExpression, AbstractPropertyExpression),
+              queryBuilderState,
+              nextExpression instanceof AbstractPropertyExpression
+                ? nextExpression
+                : undefined,
+              isDatePropagationNotSupported,
+            )
+          ) {
+            // 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 &&
+                guaranteeType(currentExpression, AbstractPropertyExpression)
+                  .parametersValues.length === 3) ||
+              (index === 0 &&
+                guaranteeType(currentExpression, AbstractPropertyExpression)
+                  .parametersValues.length === 3 &&
+                !(
+                  guaranteeType(currentExpression, AbstractPropertyExpression)
+                    .parametersValues[2] instanceof INTERNAL__PropagatedValue
+                ))
+            ) {
+              propertyExpression_setParametersValue(
+                guaranteeType(currentExpression, AbstractPropertyExpression),
+                index + 1,
+                parameterValue.getValue(),
+                queryBuilderState.observableContext,
+              );
+            } else {
+              functionExpression_setParametersValues(
+                guaranteeType(currentExpression, AbstractPropertyExpression),
+                [
+                  guaranteeNonNullable(
+                    guaranteeType(currentExpression, AbstractPropertyExpression)
+                      .parametersValues[0],
+                  ),
+                ],
+                queryBuilderState.observableContext,
+              );
+            }
+          } else {
+            propertyExpression_setParametersValue(
+              guaranteeType(currentExpression, AbstractPropertyExpression),
+              index + 1,
+              parameterValue.getValue(),
+              queryBuilderState.observableContext,
+            );
+          }
+        }
+      });
+    }
+    currentExpression = nextExpression;
+    // Take care of chains of subtype (a pattern that is not useful, but we want to support and rectify)
+    // $x.employees->subType(@Person)->subType(@Staff)
+    while (
+      currentExpression instanceof SimpleFunctionExpression &&
+      matchFunctionName(
+        currentExpression.functionName,
+        QUERY_BUILDER_SUPPORTED_FUNCTIONS.SUBTYPE,
+      )
+    ) {
+      currentExpression = getNullableFirstElement(
+        currentExpression.parametersValues,
+      );
+    }
+  }
+  return newPropertyExpression;
+};
+
+export type LambdaFunctionBuilderOption = {
+  /**
+   * Set queryBuilderState to `true` when we construct query for execution within the app.
+   * queryBuilderState will make the lambda function building process overrides several query values, such as the row limit.
+   */
+  isBuildingExecutionQuery?: boolean | undefined;
+  keepSourceInformation?: boolean | undefined;
+};

package/src/stores/QueryBuilderValueSpecificationHelper.ts

@@ -36,15 +36,22 @@ import {
   extractElementNameFromPath,
   AbstractPropertyExpression,
   isSuperType,
+  Class,
+  getMilestoneTemporalStereotype,
+  DerivedProperty,
+  MILESTONING_STEREOTYPE,
 } from '@finos/legend-graph';
 import {
   addUniqueEntry,
   guaranteeNonNullable,
   guaranteeType,
+  isNumber,
+  isString,
   UnsupportedOperationError,
 } from '@finos/legend-shared';
 import { format } from 'date-fns';
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../QueryBuilder_Const.js';
+import { getDerivedPropertyMilestoningSteoreotype } from './QueryBuilderPropertyEditorState.js';
 
 export const getNonCollectionValueSpecificationType = (
   valueSpecification: ValueSpecification,
@@ -243,3 +250,110 @@ export const buildGenericLambdaFunctionInstanceValue = (
   functionInstanceValue.values.push(lambdaFunction);
   return functionInstanceValue;
 };
+
+/**
+ * Checks if the milestoning property expression is valid in terms of number of parameter values provided
+ * in relation to its milestoning type.
+ *
+ * NOTE: this takes date propgation into account. See the table below for all
+ * the combination:
+ *
+ *             | [source] |          |          |          |          |
+ * ----------------------------------------------------------------------
+ *   [target]  |          |   NONE   |  PR_TMP  |  BI_TMP  |  BU_TMP  |
+ * ----------------------------------------------------------------------
+ *             |   NONE   |   N.A.   |   PRD    | PRD,BUD  |    BUD   |
+ * ----------------------------------------------------------------------
+ *             |  PR_TMP  |   N.A.   |    X     | PRD,BUD  |    BUD   |
+ * ----------------------------------------------------------------------
+ *             |  BI_TMP  |   N.A.   |    X     |    X     |    X     |
+ * ----------------------------------------------------------------------
+ *             |  BU_TMP  |   N.A.   |   PRD    | PRD,BUD  |    X     |
+ * ----------------------------------------------------------------------
+ *
+ * Annotations:
+ *
+ * [source]: source temporal type
+ * [target]: target temporal type
+ *
+ * PR_TMP  : processing temporal
+ * BI_TMP  : bitemporal
+ * BU_TMP  : business temporal
+ *
+ * X       : no default date propagated
+ * PRD     : default processing date is propagated
+ * BUD     : default business date is propgated
+ */
+export const validatePropertyExpressionChain = (
+  propertyExpression: AbstractPropertyExpression,
+  graph: PureModel,
+): void => {
+  if (
+    propertyExpression.func.genericType.value.rawType instanceof Class &&
+    propertyExpression.func._OWNER._generatedMilestonedProperties.length !== 0
+  ) {
+    const name = propertyExpression.func.name;
+    const func =
+      propertyExpression.func._OWNER._generatedMilestonedProperties.find(
+        (e) => e.name === name,
+      );
+    if (func) {
+      const targetStereotype = getMilestoneTemporalStereotype(
+        propertyExpression.func.genericType.value.rawType,
+        graph,
+      );
+
+      if (targetStereotype) {
+        const sourceStereotype = getDerivedPropertyMilestoningSteoreotype(
+          guaranteeType(func, DerivedProperty),
+          graph,
+        );
+        if (
+          sourceStereotype !== MILESTONING_STEREOTYPE.BITEMPORAL &&
+          targetStereotype !== sourceStereotype
+        ) {
+          if (targetStereotype === MILESTONING_STEREOTYPE.BITEMPORAL) {
+            if (
+              propertyExpression.parametersValues.length !== 3 &&
+              !sourceStereotype
+            ) {
+              throw new UnsupportedOperationError(
+                `Property of milestoning sterotype '${MILESTONING_STEREOTYPE.BITEMPORAL}' should have exactly two parameters`,
+              );
+            } else if (propertyExpression.parametersValues.length < 2) {
+              throw new UnsupportedOperationError(
+                `Property of milestoning sterotype '${MILESTONING_STEREOTYPE.BITEMPORAL}' should have at least one parameter`,
+              );
+            } else if (propertyExpression.parametersValues.length > 3) {
+              throw new UnsupportedOperationError(
+                `Property of milestoning sterotype '${MILESTONING_STEREOTYPE.BITEMPORAL}' should not have more than two parameters`,
+              );
+            }
+          } else if (propertyExpression.parametersValues.length !== 2) {
+            throw new UnsupportedOperationError(
+              `Property of milestoning sterotype '${targetStereotype}' should have exactly one parameter`,
+            );
+          }
+        }
+      }
+    }
+  }
+};
+
+export const extractNullableStringFromInstanceValue = (
+  value: ValueSpecification,
+): string | undefined => {
+  if (value instanceof PrimitiveInstanceValue && isString(value.values[0])) {
+    return value.values[0];
+  }
+  return undefined;
+};
+
+export const extractNullableNumberFromInstanceValue = (
+  value: ValueSpecification,
+): number | undefined => {
+  if (value instanceof PrimitiveInstanceValue && isNumber(value.values[0])) {
+    return value.values[0];
+  }
+  return undefined;
+};

package/src/stores/explorer/QueryBuilderExplorerState.ts

@@ -57,6 +57,7 @@ import {
   PRIMITIVE_TYPE,
   TdsExecutionResult,
   type ExecutionResult,
+  getAllSubclasses,
 } from '@finos/legend-graph';
 import type { QueryBuilderState } from '../QueryBuilderState.js';
 import {
@@ -76,7 +77,7 @@ import {
   buildNumericPreviewDataQuery,
   type QueryBuilderPreviewData,
 } from '../QueryBuilderPreviewDataHelper.js';
-import { QueryBuilderPropertySearchPanelState } from './QueryBuilderPropertySearchPanelState.js';
+import { QueryBuilderPropertySearchState } from './QueryBuilderPropertySearchPanelState.js';
 
 export enum QUERY_BUILDER_EXPLORER_TREE_DND_TYPE {
   ROOT = 'ROOT',
@@ -85,6 +86,16 @@ export enum QUERY_BUILDER_EXPLORER_TREE_DND_TYPE {
   PRIMITIVE_PROPERTY = 'PRIMITIVE_PROPERTY',
 }
 
+export const generateExplorerTreePropertyNodeID = (
+  parentId: string,
+  propertyName: string,
+): string => `${parentId ? `${parentId}.` : ''}${propertyName}`;
+
+export const generateExplorerTreeSubtypeNodeID = (
+  parentId: string,
+  subClassPath: string,
+): string => `${parentId ? parentId : ''}${TYPE_CAST_TOKEN}${subClassPath}`;
+
 export interface QueryBuilderExplorerTreeDragSource {
   node: QueryBuilderExplorerTreePropertyNodeData;
 }
@@ -98,7 +109,7 @@ export abstract class QueryBuilderExplorerTreeNodeData implements TreeNodeData {
   childrenIds: string[] = [];
   isPartOfDerivedPropertyBranch: boolean;
   type: Type;
-  mappingData: QueryBuilderPropertyMappingData;
+  mappingData: QueryBuilderExplorerTreeNodeMappingData;
 
   constructor(
     id: string,
@@ -106,7 +117,7 @@ export abstract class QueryBuilderExplorerTreeNodeData implements TreeNodeData {
     dndText: string,
     isPartOfDerivedPropertyBranch: boolean,
     type: Type,
-    mappingData: QueryBuilderPropertyMappingData,
+    mappingData: QueryBuilderExplorerTreeNodeMappingData,
   ) {
     makeObservable(this, {
       isSelected: observable,
@@ -126,7 +137,7 @@ export abstract class QueryBuilderExplorerTreeNodeData implements TreeNodeData {
   }
 }
 
-export type QueryBuilderPropertyMappingData = {
+export type QueryBuilderExplorerTreeNodeMappingData = {
   mapped: boolean;
   mappedEntity?: MappedEntity | undefined;
 };
@@ -144,7 +155,7 @@ export class QueryBuilderExplorerTreePropertyNodeData extends QueryBuilderExplor
     property: AbstractProperty,
     parentId: string,
     isPartOfDerivedPropertyBranch: boolean,
-    mappingData: QueryBuilderPropertyMappingData,
+    mappingData: QueryBuilderExplorerTreeNodeMappingData,
   ) {
     super(
       id,
@@ -171,7 +182,7 @@ export class QueryBuilderExplorerTreeSubTypeNodeData extends QueryBuilderExplore
     subclass: Class,
     parentId: string,
     isPartOfDerivedPropertyBranch: boolean,
-    mappingData: QueryBuilderPropertyMappingData,
+    mappingData: QueryBuilderExplorerTreeNodeMappingData,
     multiplicity: Multiplicity,
   ) {
     super(
@@ -216,6 +227,16 @@ export const buildPropertyExpressionFromExplorerTreeNodeData = (
     parentNode instanceof QueryBuilderExplorerTreePropertyNodeData ||
     parentNode instanceof QueryBuilderExplorerTreeSubTypeNodeData
   ) {
+    // NOTE: here, we deliverately simplify subtypes chain
+    // $x.employees->subType(@Person)->subType(@Staff).department will be simplified to $x.employees->subType(@Staff).department
+    if (
+      parentNode instanceof QueryBuilderExplorerTreeSubTypeNodeData &&
+      currentNode instanceof QueryBuilderExplorerTreeSubTypeNodeData
+    ) {
+      parentNode = treeData.nodes.get(parentNode.parentId);
+      continue;
+    }
+
     let parentPropertyExpression;
     if (parentNode instanceof QueryBuilderExplorerTreeSubTypeNodeData) {
       parentPropertyExpression = new SimpleFunctionExpression(
@@ -272,11 +293,11 @@ export const buildPropertyExpressionFromExplorerTreeNodeData = (
 
 export const generatePropertyNodeMappingData = (
   property: AbstractProperty,
-  parentMappingData: QueryBuilderPropertyMappingData,
+  parentMappingData: QueryBuilderExplorerTreeNodeMappingData,
   modelCoverageAnalysisResult: MappingModelCoverageAnalysisResult,
-): QueryBuilderPropertyMappingData => {
-  // If this property's owner has no corresponding entity, i.e. it means the parent is not mapped
-  // Therefore, this property is not mapped either.
+): QueryBuilderExplorerTreeNodeMappingData => {
+  // If the property node's parent node does not have a mapped entity,
+  // it means the owner class is not mapped, i.e. this property is not mapped.
   if (parentMappingData.mappedEntity) {
     const mappedProp = parentMappingData.mappedEntity.__PROPERTIES_INDEX.get(
       property.name,
@@ -301,25 +322,57 @@ export const generatePropertyNodeMappingData = (
   return { mapped: false };
 };
 
-const generateSubtypeNodeMappingData = (
+export const generateSubtypeNodeMappingData = (
   subclass: Class,
-  parentMappingData: QueryBuilderPropertyMappingData,
+  parentMappingData: QueryBuilderExplorerTreeNodeMappingData,
   modelCoverageAnalysisResult: MappingModelCoverageAnalysisResult,
-): QueryBuilderPropertyMappingData => {
-  // If this property's owner has no corresponding entity, i.e. it means the parent is not mapped
-  // Therefore, this property is not mapped either.
+): QueryBuilderExplorerTreeNodeMappingData => {
+  // NOTE: since we build subclass trees, there's a chance in a particular case,
+  // a _deep_ subclass is mapped, for example: A extends B extends C extends D ... extends Z
+  // and Z is mapped, when we build the mapping data for node A, B, C, we need to make sure
+  // we are aware of the fact that Z is mapped and pass the mapping data information properly
+  // until we process the node Z.
+  const allCompatibleTypePaths = getAllSubclasses(subclass)
+    .concat(subclass)
+    .map((_class) => _class.path);
+  // If the subtype node's parent node does not have a mapped entity,
+  // it means the superclass is not mapped, i.e. this subtype is not mapped
   if (parentMappingData.mappedEntity) {
-    const mappedProperty = parentMappingData.mappedEntity.properties.filter(
-      (p) => p instanceof EntityMappedProperty && p.subType === subclass.path,
+    const mappedSubtype = parentMappingData.mappedEntity.properties.find(
+      (mappedProperty): mappedProperty is EntityMappedProperty =>
+        Boolean(
+          // NOTE: if `subType` is specified in `EntityMappedProperty` it means
+          // that subtype is mapped
+          mappedProperty instanceof EntityMappedProperty &&
+            mappedProperty.subType &&
+            allCompatibleTypePaths.includes(mappedProperty.subType),
+        ),
     );
-    if (mappedProperty.length > 0) {
+    if (mappedSubtype) {
       return {
         mapped: true,
         mappedEntity: modelCoverageAnalysisResult.__ENTITIES_INDEX.get(
-          (mappedProperty[0] as EntityMappedProperty).entityPath,
+          mappedSubtype.entityPath,
         ),
       };
-    } else if (parentMappingData.mappedEntity.path === subclass.path) {
+    } else if (
+      allCompatibleTypePaths.includes(parentMappingData.mappedEntity.path)
+    ) {
+      // This is to handle the case where the property mapping is pointing
+      // directly at the class mapping of a subtype of the type of that property
+      //
+      // For example: we have class `A` extends `B`, and we're looking at class `C` with property
+      // `b` of type B. However, the mapping we use has property mapping for `b` pointing at
+      // a class mapping for `A`.
+      //
+      // In this case, when building explorer tree node for property `b` of `C`, according to
+      // the mapping model coverage result, the mapped entity corresponding to this property
+      // will be mapped entity for `A`. However, as we build the explorer tree,
+      // so we will not immediately build the subtype node for `A`. As such, we have to propagate
+      // the mapped entity data downstream like the following. As a result, when building
+      // the mapping data for subtype node, we have to take this case into consideration
+      //
+      // See https://github.com/finos/legend-studio/issues/1437
       return {
         mapped: true,
         mappedEntity: parentMappingData.mappedEntity,
@@ -332,7 +385,7 @@ const generateSubtypeNodeMappingData = (
 export const getRootMappingData = (
   _class: Class,
   modelCoverageAnalysisResult: MappingModelCoverageAnalysisResult,
-): QueryBuilderPropertyMappingData => ({
+): QueryBuilderExplorerTreeNodeMappingData => ({
   mapped: true,
   mappedEntity: modelCoverageAnalysisResult.__ENTITIES_INDEX.get(_class.path),
 });
@@ -385,11 +438,12 @@ export const getQueryBuilderPropertyNodeData = (
     return undefined;
   }
   const propertyNode = new QueryBuilderExplorerTreePropertyNodeData(
-    `${
+    generateExplorerTreePropertyNodeID(
       parentNode instanceof QueryBuilderExplorerTreeRootNodeData
         ? ''
-        : `${parentNode.id}.`
-    }${property.name}`,
+        : parentNode.id,
+      property.name,
+    ),
     property.name,
     `${
       parentNode instanceof QueryBuilderExplorerTreeRootNodeData
@@ -414,11 +468,12 @@ export const getQueryBuilderSubTypeNodeData = (
   modelCoverageAnalysisResult: MappingModelCoverageAnalysisResult,
 ): QueryBuilderExplorerTreeSubTypeNodeData => {
   const subTypeNode = new QueryBuilderExplorerTreeSubTypeNodeData(
-    `${
+    generateExplorerTreeSubtypeNodeID(
       parentNode instanceof QueryBuilderExplorerTreeRootNodeData
-        ? `${TYPE_CAST_TOKEN}${subclass.path}`
-        : `${parentNode.id}${TYPE_CAST_TOKEN}${subclass.path}`
-    }`,
+        ? ''
+        : parentNode.id,
+      subclass.path,
+    ),
     subclass.name,
     `${
       parentNode instanceof QueryBuilderExplorerTreeRootNodeData
@@ -464,7 +519,6 @@ const getQueryBuilderTreeData = (
     '@dummy_rootNode',
     rootClass.name,
     rootClass.path,
-
     false,
     rootClass,
     mappingData,
@@ -536,7 +590,8 @@ export class QueryBuilderExplorerState {
   treeData?: TreeData<QueryBuilderExplorerTreeNodeData> | undefined;
   humanizePropertyName = true;
   showUnmappedProperties = false;
-  propertySearchPanelState: QueryBuilderPropertySearchPanelState;
+  highlightUsedProperties = true;
+  propertySearchState: QueryBuilderPropertySearchState;
   mappingModelCoverageAnalysisResult?: MappingModelCoverageAnalysisResult;
   mappingModelCoverageAnalysisState = ActionState.create();
 
@@ -545,17 +600,19 @@ export class QueryBuilderExplorerState {
       queryBuilderState: false,
       previewDataState: false,
       treeData: observable.ref,
+      highlightUsedProperties: observable,
       setTreeData: action,
       refreshTree: action,
       refreshTreeData: action,
       setHumanizePropertyName: action,
       setShowUnmappedProperties: action,
       previewData: flow,
+      setHighlightUsedProperties: action,
       analyzeMappingModelCoverage: flow,
     });
 
     this.queryBuilderState = queryBuilderState;
-    this.propertySearchPanelState = new QueryBuilderPropertySearchPanelState(
+    this.propertySearchState = new QueryBuilderPropertySearchState(
       this.queryBuilderState,
     );
   }
@@ -587,6 +644,10 @@ export class QueryBuilderExplorerState {
     this.showUnmappedProperties = val;
   }
 
+  setHighlightUsedProperties(val: boolean): void {
+    this.highlightUsedProperties = val;
+  }
+
   refreshTreeData(): void {
     const _class = this.queryBuilderState.querySetupState._class;
     const _mapping = this.queryBuilderState.querySetupState.mapping;
@@ -658,7 +719,7 @@ export class QueryBuilderExplorerState {
       this.queryBuilderState.explorerState.nonNullableTreeData,
       node,
       this.queryBuilderState.graphManagerState.graph,
-      this.queryBuilderState.explorerState.propertySearchPanelState
+      this.queryBuilderState.explorerState.propertySearchState
         .allMappedPropertyNodes,
     );
     const propertyType = node.property.genericType.value.rawType;

package/src/stores/explorer/QueryBuilderPropertySearchPanelState.ts

@@ -42,8 +42,10 @@ import {
 } from './QueryBuilderExplorerState.js';
 import type { QueryBuilderState } from '../QueryBuilderState.js';
 
-export class QueryBuilderPropertySearchPanelState {
+export class QueryBuilderPropertySearchState {
   queryBuilderState: QueryBuilderState;
+  // TODO: Check if we could clean this up as this seems quite complicated and its purpose is not clear to me
+  // See https://github.com/finos/legend-studio/pull/1212
   allMappedPropertyNodes: QueryBuilderExplorerTreeNodeData[] = [];
   searchedMappedPropertyNodes: QueryBuilderExplorerTreeNodeData[] = [];
   isSearchPanelOpen = false;