@finos/legend-extension-dsl-data-space 10.4.2 → 10.4.3

package/src/graph-manager/protocol/pure/v1/V1_DSL_DataSpace_PureGraphManagerExtension.ts

@@ -19,8 +19,6 @@ import {
   type AbstractPureGraphManager,
   type PureProtocolProcessorPlugin,
   type MappingModelCoverageAnalysisResult,
-  type GraphManagerOperationReport,
-  type FunctionAnalysisInfo,
   PureModel,
   V1_PureGraphManager,
   PureClientVersion,
@@ -38,13 +36,8 @@ import {
   V1_deserializePackageableElement,
   QueryDataSpaceExecutionContextInfo,
   V1_RemoteEngine,
-  LegendSDLC,
-  PackageableElementPointerType,
-  V1_PackageableElementPointer,
-  V1_ConcreteFunctionDefinition,
-  V1_buildFunctionInfoAnalysis,
 } from '@finos/legend-graph';
-import type { Entity, ProjectGAVCoordinates } from '@finos/legend-storage';
+import type { Entity } from '@finos/legend-storage';
 import {
   type PlainObject,
   ActionState,
@@ -63,7 +56,6 @@ import {
 } from '../../../../graph/metamodel/pure/model/packageableElements/dataSpace/DSL_DataSpace_DataSpace.js';
 import {
   V1_DataSpace,
-  V1_DataSpaceExecutionContext,
   V1_DataSpaceSupportCombinedInfo,
   V1_DataSpaceSupportEmail,
   V1_DataSpaceTemplateExecutable,
@@ -104,7 +96,6 @@ import {
   V1_DataSpaceFunctionPointerExecutableInfo,
 } from './engine/analytics/V1_DataSpaceAnalysis.js';
 import { getDiagram } from '@finos/legend-extension-dsl-diagram/graph';
-import { resolveVersion } from '@finos/legend-server-depot';
 
 const ANALYZE_DATA_SPACE_TRACE = 'analyze data space';
 const TEMPORARY__TDS_SAMPLE_VALUES__DELIMETER = '-- e.g.';
@@ -228,112 +219,6 @@ export class V1_DSL_DataSpace_PureGraphManagerExtension extends DSL_DataSpace_Pu
     );
   }
 
-  retrieveExecutionContextFromTemplateQueryId(
-    dataSpaceAnalysisResult: PlainObject<V1_DataSpaceAnalysisResult>,
-    templateQueryId: string,
-    plugins: PureProtocolProcessorPlugin[],
-  ): string | undefined {
-    const analysisResult = V1_deserializeDataSpaceAnalysisResult(
-      dataSpaceAnalysisResult,
-      plugins,
-    );
-    let execContext = undefined;
-    const info = analysisResult.executables.find(
-      (ex) => ex.info?.id === templateQueryId,
-    )?.info;
-    if (info) {
-      execContext =
-        info.executionContextKey ?? analysisResult.defaultExecutionContext;
-    }
-    return execContext;
-  }
-
-  async analyzeDataSpaceCoverage(
-    dataSpacePath: string,
-    entitiesRetriever: () => Promise<Entity[]>,
-    entitiesWithClassifierRetriever: () => Promise<
-      [PlainObject<Entity>[], PlainObject<Entity>[]]
-    >,
-    cacheRetriever?: () => Promise<PlainObject<DataSpaceAnalysisResult>>,
-    actionState?: ActionState,
-    graphReport?: GraphManagerOperationReport | undefined,
-    pureGraph?: PureModel | undefined,
-    executionContext?: string | undefined,
-    mappingPath?: string | undefined,
-    projectInfo?: ProjectGAVCoordinates,
-    templateQueryId?: string,
-  ): Promise<DataSpaceAnalysisResult> {
-    const cacheResult = cacheRetriever
-      ? await this.fetchDataSpaceAnalysisFromCache(cacheRetriever, actionState)
-      : undefined;
-    const engineClient = guaranteeType(
-      this.graphManager.engine,
-      V1_RemoteEngine,
-      'analyzeDataSpaceCoverage is only supported by remote engine',
-    ).getEngineServerClient();
-    let analysisResult: PlainObject<V1_DataSpaceAnalysisResult>;
-    let cachedAnalysisResult;
-    if (cacheResult) {
-      cachedAnalysisResult = V1_deserializeDataSpaceAnalysisResult(
-        cacheResult,
-        this.graphManager.pluginManager.getPureProtocolProcessorPlugins(),
-      );
-    }
-    if (
-      cacheResult &&
-      cachedAnalysisResult?.executionContexts.every(
-        (e) =>
-          e.mappingModelCoverageAnalysisResult?.model !== undefined ||
-          cachedAnalysisResult.mappingToMappingCoverageResult?.get(e.mapping)
-            ?.model !== undefined,
-      )
-    ) {
-      analysisResult = cacheResult;
-    } else {
-      actionState?.setMessage('Fetching project entities and dependencies...');
-      const entities = await entitiesRetriever();
-      actionState?.setMessage('Analyzing data space...');
-      analysisResult = await engineClient.postWithTracing<
-        PlainObject<V1_DataSpaceAnalysisResult>
-      >(
-        engineClient.getTraceData(ANALYZE_DATA_SPACE_TRACE),
-        `${engineClient._pure()}/analytics/dataSpace/coverage`,
-        {
-          clientVersion: V1_PureGraphManager.DEV_PROTOCOL_VERSION,
-          dataSpace: dataSpacePath,
-          model: {
-            _type: V1_PureModelContextType.DATA,
-            elements: entities.map((entity) => entity.content),
-          },
-        },
-        {},
-        undefined,
-        undefined,
-        { enableCompression: true },
-      );
-    }
-    const plugins =
-      this.graphManager.pluginManager.getPureProtocolProcessorPlugins();
-    return this.buildDataSpaceAnalytics(
-      analysisResult,
-      plugins,
-      graphReport,
-      pureGraph,
-      executionContext
-        ? executionContext
-        : templateQueryId
-          ? this.retrieveExecutionContextFromTemplateQueryId(
-              analysisResult,
-              templateQueryId,
-              plugins,
-            )
-          : undefined,
-      mappingPath,
-      projectInfo,
-      entitiesWithClassifierRetriever,
-    );
-  }
-
   async retrieveDataSpaceAnalysisFromCache(
     cacheRetriever: () => Promise<PlainObject<DataSpaceAnalysisResult>>,
     actionState?: ActionState,
@@ -370,78 +255,11 @@ export class V1_DSL_DataSpace_PureGraphManagerExtension extends DSL_DataSpace_Pu
     return cacheResult;
   }
 
-  // build function analysis info by fetching functions within this project from metadata when building minimal graph
-  async processFunctionForMinimalGraph(
-    entitiesWithClassifierRetriever: () => Promise<
-      [PlainObject<Entity>[], PlainObject<Entity>[]]
-    >,
-    graph: PureModel,
-    dataSpaceAnalysisResult: DataSpaceAnalysisResult,
-    plugins: PureProtocolProcessorPlugin[],
-  ): Promise<void> {
-    const [functionEntities, dependencyFunctionEntities]: [
-      PlainObject<Entity>[],
-      PlainObject<Entity>[],
-    ] = await entitiesWithClassifierRetriever();
-    const functionProtocols = functionEntities.map((func) =>
-      guaranteeType(
-        V1_deserializePackageableElement(
-          (func.entity as Entity).content,
-          plugins,
-        ),
-        V1_ConcreteFunctionDefinition,
-      ),
-    );
-    const dependencyFunctionProtocols = dependencyFunctionEntities.map((func) =>
-      guaranteeType(
-        V1_deserializePackageableElement(
-          (func.entity as Entity).content,
-          plugins,
-        ),
-        V1_ConcreteFunctionDefinition,
-      ),
-    );
-    const functionInfos = V1_buildFunctionInfoAnalysis(
-      functionProtocols,
-      graph,
-    );
-    const dependencyFunctionInfos = V1_buildFunctionInfoAnalysis(
-      dependencyFunctionProtocols,
-      graph,
-    );
-    if (functionInfos.length > 0) {
-      const functionInfoMap = new Map<string, FunctionAnalysisInfo>();
-      functionInfos.forEach((funcInfo) => {
-        functionInfoMap.set(funcInfo.functionPath, funcInfo);
-      });
-      dataSpaceAnalysisResult.functionInfos = functionInfoMap;
-    }
-    if (dependencyFunctionInfos.length > 0) {
-      const dependencyFunctionInfoMap = new Map<string, FunctionAnalysisInfo>();
-      functionInfos.forEach((funcInfo) => {
-        dependencyFunctionInfoMap.set(funcInfo.functionPath, funcInfo);
-      });
-      dataSpaceAnalysisResult.dependencyFunctionInfos =
-        dependencyFunctionInfoMap;
-    }
-  }
-
   async buildDataSpaceAnalytics(
-    analytics: PlainObject<V1_DataSpaceAnalysisResult>,
+    json: PlainObject<V1_DataSpaceAnalysisResult>,
     plugins: PureProtocolProcessorPlugin[],
-    graphReport?: GraphManagerOperationReport | undefined,
-    pureGraph?: PureModel | undefined,
-    executionContext?: string | undefined,
-    mappingPath?: string | undefined,
-    projectInfo?: ProjectGAVCoordinates,
-    entitiesWithClassifierRetriever?: () => Promise<
-      [PlainObject<Entity>[], PlainObject<Entity>[]]
-    >,
   ): Promise<DataSpaceAnalysisResult> {
-    const analysisResult = V1_deserializeDataSpaceAnalysisResult(
-      analytics,
-      plugins,
-    );
+    const analysisResult = V1_deserializeDataSpaceAnalysisResult(json, plugins);
     const result = new DataSpaceAnalysisResult();
     result.name = analysisResult.name;
     result.package = analysisResult.package;
@@ -488,30 +306,26 @@ export class V1_DSL_DataSpace_PureGraphManagerExtension extends DSL_DataSpace_Pu
       // NOTE: we will relax the check and not throw here for unknown support info type
     }
 
-    let graphEntities;
-    let graph: PureModel;
-    let minialGraph = false;
-    if (pureGraph) {
-      graph = pureGraph;
-    } else {
-      // create an empty graph
-      const extensionElementClasses =
-        this.graphManager.pluginManager.getPureGraphPlugins();
-      const systemModel = new SystemModel(extensionElementClasses);
-      const coreModel = new CoreModel(extensionElementClasses);
-      await this.graphManager.buildSystem(
-        coreModel,
-        systemModel,
-        ActionState.create(),
-        {},
-      );
-      systemModel.initializeAutoImports();
-      graph = new PureModel(
-        coreModel,
-        systemModel,
-        this.graphManager.pluginManager.getPureGraphPlugins(),
-      );
-    }
+    // create an empty graph
+    const systemModel = new SystemModel(
+      this.graphManager.pluginManager.getPureGraphPlugins(),
+    );
+    const coreModel = new CoreModel(
+      this.graphManager.pluginManager.getPureGraphPlugins(),
+    );
+    await this.graphManager.buildSystem(
+      coreModel,
+      systemModel,
+      ActionState.create(),
+      {},
+    );
+    systemModel.initializeAutoImports();
+    const graph = new PureModel(
+      coreModel,
+      systemModel,
+      this.graphManager.pluginManager.getPureGraphPlugins(),
+    );
+
     // Create dummy mappings and runtimes
     // TODO?: these stubbed mappings and runtimes are not really useful that useful, so either we should
     // simplify the model here or potentially refactor the backend analytics endpoint to return these as model
@@ -541,142 +355,55 @@ export class V1_DSL_DataSpace_PureGraphManagerExtension extends DSL_DataSpace_Pu
       return runtime;
     });
 
-    // The DataSpace entity is excluded from AnalyticsResult.Json to reduce the JSON size
-    // because all its information can be found in V1_DataSpaceAnalysisResult.
-    // Therefore, we are building a simple v1_DataSpace entity based on V1_DataSpaceAnalysisResult.
-    const dataspaceEntity = new V1_DataSpace();
-    dataspaceEntity.name = analysisResult.name;
-    dataspaceEntity.package = analysisResult.package;
-    dataspaceEntity.supportInfo = analysisResult.supportInfo;
-    dataspaceEntity.executionContexts = analysisResult.executionContexts.map(
-      (execContext) => {
-        const contextProtocol = new V1_DataSpaceExecutionContext();
-        contextProtocol.name = execContext.name;
-        contextProtocol.title = execContext.title;
-        contextProtocol.description = execContext.description;
-        contextProtocol.mapping = new V1_PackageableElementPointer(
-          PackageableElementPointerType.MAPPING,
-          execContext.mapping,
-        );
-        contextProtocol.defaultRuntime = new V1_PackageableElementPointer(
-          PackageableElementPointerType.RUNTIME,
-          execContext.defaultRuntime,
-        );
-        return contextProtocol;
-      },
-    );
-    dataspaceEntity.defaultExecutionContext =
-      analysisResult.defaultExecutionContext;
-    dataspaceEntity.title = analysisResult.title;
-    dataspaceEntity.description = analysisResult.description;
-
-    const resolvedMappingPath =
-      mappingPath ??
-      analysisResult.executionContexts.find(
-        (value) =>
-          value.name ===
-          (executionContext ?? analysisResult.defaultExecutionContext),
-      )?.mapping;
-    let pmcd;
-    if (resolvedMappingPath) {
-      const mappingModelCoverageAnalysisResult =
-        analysisResult.mappingToMappingCoverageResult?.get(resolvedMappingPath);
-      pmcd = mappingModelCoverageAnalysisResult?.model;
-    }
-    if (pmcd && projectInfo) {
-      graphEntities = pmcd.elements
-        .concat(mappingModels)
-        .concat(runtimeModels)
-        .concat(dataspaceEntity)
-        // NOTE: if an element could be found in the graph already it means it comes from system
-        // so we could rid of it
-        .filter((el) => !graph.getNullableElement(el.path, false))
-        .map((el) => this.graphManager.elementProtocolToEntity(el));
-      await this.graphManager.buildGraph(
-        graph,
-        graphEntities,
-        ActionState.create(),
-        {
-          origin: new LegendSDLC(
-            projectInfo.groupId,
-            projectInfo.artifactId,
-            resolveVersion(projectInfo.versionId),
-          ),
-        },
-        graphReport,
-      );
-      if (entitiesWithClassifierRetriever) {
-        try {
-          await this.processFunctionForMinimalGraph(
-            entitiesWithClassifierRetriever,
-            graph,
-            result,
-            plugins,
-          );
-        } catch {
-          //do nothing
-        }
-      }
-      minialGraph = true;
-    } else {
-      const elements = analysisResult.model.elements
-        // NOTE: this is a temporary hack to fix a problem with data space analytics
-        // where the classes for properties are not properly surveyed
-        // We need to wait for the actual fix in backend to be merged and released
-        // See https://github.com/finos/legend-engine/pull/836
-        .concat(
-          uniq(
-            analysisResult.model.elements.flatMap((element) => {
-              if (element instanceof V1_Class) {
-                return element.derivedProperties
-                  .map((prop) => prop.returnType)
-                  .concat(element.properties.map((prop) => prop.type));
-              }
-              return [];
-            }),
-          )
-            // make sure to not include types already returned by the analysis
-            .filter(
-              (path) =>
-                !analysisResult.model.elements
-                  .map((el) => el.path)
-                  .includes(path),
-            )
-            .map((path) => {
-              const [pkgPath, name] = resolvePackagePathAndElementName(path);
-              if (!pkgPath) {
-                // exclude package-less elements (i.e. primitive types)
-                return undefined;
-              }
-              const _class = new V1_Class();
-              _class.name = name;
-              _class.package = pkgPath;
-              return _class;
-            })
-            .filter(isNonNullable),
+    // prepare the model context data
+    const graphEntities = analysisResult.model.elements
+      // NOTE: this is a temporary hack to fix a problem with data space analytics
+      // where the classes for properties are not properly surveyed
+      // We need to wait for the actual fix in backend to be merged and released
+      // See https://github.com/finos/legend-engine/pull/836
+      .concat(
+        uniq(
+          analysisResult.model.elements.flatMap((element) => {
+            if (element instanceof V1_Class) {
+              return element.derivedProperties
+                .map((prop) => prop.returnType)
+                .concat(element.properties.map((prop) => prop.type));
+            }
+            return [];
+          }),
         )
-        .concat(mappingModels)
-        .concat(runtimeModels);
-      const alreadyContainsDataspace = elements.find(
-        (e) => e.path === dataspaceEntity.path,
-      );
-      let allElements = elements;
-      if (!alreadyContainsDataspace) {
-        allElements = elements.concat(dataspaceEntity);
-      }
-      // prepare the model context data
-      graphEntities = allElements
-        // NOTE: if an element could be found in the graph already it means it comes from system
-        // so we could rid of it
-        .filter((el) => !graph.getNullableElement(el.path, false))
-        .map((el) => this.graphManager.elementProtocolToEntity(el));
-
-      await this.graphManager.buildGraph(
-        graph,
-        graphEntities,
-        ActionState.create(),
-      );
-    }
+          // make sure to not include types already returned by the analysis
+          .filter(
+            (path) =>
+              !analysisResult.model.elements
+                .map((el) => el.path)
+                .includes(path),
+          )
+          .map((path) => {
+            const [pkgPath, name] = resolvePackagePathAndElementName(path);
+            if (!pkgPath) {
+              // exclude package-less elements (i.e. primitive types)
+              return undefined;
+            }
+            const _class = new V1_Class();
+            _class.name = name;
+            _class.package = pkgPath;
+            return _class;
+          })
+          .filter(isNonNullable),
+      )
+      .concat(mappingModels)
+      .concat(runtimeModels)
+      // NOTE: if an element could be found in the graph already it means it comes from system
+      // so we could rid of it
+      .filter((el) => !graph.getNullableElement(el.path, false))
+      .map((el) => this.graphManager.elementProtocolToEntity(el));
+
+    await this.graphManager.buildGraph(
+      graph,
+      graphEntities,
+      ActionState.create(),
+    );
 
     const mappingToMappingCoverageResult = new Map<
       string,
@@ -687,11 +414,7 @@ export class V1_DSL_DataSpace_PureGraphManagerExtension extends DSL_DataSpace_Pu
         ([key, value]) => {
           mappingToMappingCoverageResult.set(
             key,
-            V1_buildModelCoverageAnalysisResult(
-              value,
-              this.graphManager,
-              graph.getMapping(key),
-            ),
+            V1_buildModelCoverageAnalysisResult(value, graph.getMapping(key)),
           );
         },
       );
@@ -732,7 +455,6 @@ export class V1_DSL_DataSpace_PureGraphManagerExtension extends DSL_DataSpace_Pu
           context.mapping,
           V1_buildModelCoverageAnalysisResult(
             context.mappingModelCoverageAnalysisResult,
-            this.graphManager,
             contextAnalysisResult.mapping,
           ),
         );
@@ -864,15 +586,13 @@ export class V1_DSL_DataSpace_PureGraphManagerExtension extends DSL_DataSpace_Pu
     });
 
     // diagrams
-    result.diagrams = (minialGraph ? [] : analysisResult.diagrams).map(
-      (diagramProtocol) => {
-        const diagram = new DataSpaceDiagramAnalysisResult();
-        diagram.title = diagramProtocol.title;
-        diagram.description = diagramProtocol.description;
-        diagram.diagram = getDiagram(diagramProtocol.diagram, graph);
-        return diagram;
-      },
-    );
+    result.diagrams = analysisResult.diagrams.map((diagramProtocol) => {
+      const diagram = new DataSpaceDiagramAnalysisResult();
+      diagram.title = diagramProtocol.title;
+      diagram.description = diagramProtocol.description;
+      diagram.diagram = getDiagram(diagramProtocol.diagram, graph);
+      return diagram;
+    });
 
     // executables
     result.executables = analysisResult.executables.map(

package/src/stores/query-builder/DataSpaceQueryBuilderState.ts

@@ -34,6 +34,7 @@ import {
   Package,
   QueryDataSpaceExecutionContext,
   elementBelongsToPackage,
+  RuntimePointer,
 } from '@finos/legend-graph';
 import {
   type DepotServerClient,
@@ -46,6 +47,7 @@ import {
   ActionState,
   assertErrorThrown,
   filterByType,
+  getNullableFirstEntry,
 } from '@finos/legend-shared';
 import { action, flow, makeObservable, observable } from 'mobx';
 import { renderDataSpaceQueryBuilderSetupPanelContent } from '../../components/query-builder/DataSpaceQueryBuilder.js';
@@ -86,34 +88,11 @@ export const resolveUsableDataSpaceClasses = (
   dataSpace: DataSpace,
   mapping: Mapping,
   graphManagerState: GraphManagerState,
-  queryBuilderState?: DataSpaceQueryBuilderState,
 ): Class[] => {
-  let compatibleClasses = getMappingCompatibleClasses(
+  const compatibleClasses = getMappingCompatibleClasses(
     mapping,
     graphManagerState.usableClasses,
   );
-  const mappingModelCoverageAnalysisResult =
-    queryBuilderState?.dataSpaceAnalysisResult?.mappingToMappingCoverageResult?.get(
-      mapping.path,
-    );
-  if (
-    // This check is to make sure that we have `info` field present in `MappedEntity` which
-    // contains information about the mapped class path
-    mappingModelCoverageAnalysisResult?.mappedEntities.some(
-      (m) => m.info !== undefined,
-    )
-  ) {
-    const compatibleClassPaths =
-      mappingModelCoverageAnalysisResult.mappedEntities.map(
-        (e) => e.info?.classPath,
-      );
-    const uniqueCompatibleClasses = compatibleClassPaths.filter(
-      (val, index) => compatibleClassPaths.indexOf(val) === index,
-    );
-    compatibleClasses = graphManagerState.graph.classes.filter((c) =>
-      uniqueCompatibleClasses.includes(c.path),
-    );
-  }
   if (dataSpace.elements?.length) {
     const elements = dataSpace.elements;
     return compatibleClasses.filter((_class) => {
@@ -356,7 +335,7 @@ export class DataSpacesDepotRepository extends DataSpacesBuilderRepoistory {
 }
 
 export class DataSpaceQueryBuilderState extends QueryBuilderState {
-  readonly onDataSpaceChange: (val: DataSpaceInfo) => Promise<void>;
+  readonly onDataSpaceChange: (val: DataSpaceInfo) => void;
   readonly onExecutionContextChange?:
     | ((val: DataSpaceExecutionContext) => void)
     | undefined;
@@ -372,7 +351,6 @@ export class DataSpaceQueryBuilderState extends QueryBuilderState {
   executionContext!: DataSpaceExecutionContext;
   showRuntimeSelector = false;
   isTemplateQueryDialogOpen = false;
-  isLightGraphEnabled!: boolean;
   displayedTemplateQueries: DataSpaceExecutableAnalysisResult[] | undefined;
 
   constructor(
@@ -382,9 +360,8 @@ export class DataSpaceQueryBuilderState extends QueryBuilderState {
     actionConfig: QueryBuilderActionConfig,
     dataSpace: DataSpace,
     executionContext: DataSpaceExecutionContext,
-    isLightGraphEnabled: boolean,
     dataSpaceRepo: DataSpacesBuilderRepoistory | undefined,
-    onDataSpaceChange: (val: DataSpaceInfo) => Promise<void>,
+    onDataSpaceChange: (val: DataSpaceInfo) => void,
     dataSpaceAnalysisResult?: DataSpaceAnalysisResult | undefined,
     onExecutionContextChange?:
       | ((val: DataSpaceExecutionContext) => void)
@@ -400,12 +377,10 @@ export class DataSpaceQueryBuilderState extends QueryBuilderState {
       executionContext: observable,
       showRuntimeSelector: observable,
       isTemplateQueryDialogOpen: observable,
-      isLightGraphEnabled: observable,
       displayedTemplateQueries: observable,
       setExecutionContext: action,
       setShowRuntimeSelector: action,
       setTemplateQueryDialogOpen: action,
-      setIsLightGraphEnabled: action,
       intialize: flow,
     });
 
@@ -450,8 +425,41 @@ export class DataSpaceQueryBuilderState extends QueryBuilderState {
     this.showRuntimeSelector = val;
   }
 
-  setIsLightGraphEnabled(val: boolean): void {
-    this.isLightGraphEnabled = val;
+  /**
+   * Propagation after changing the execution context:
+   * - The mapping will be updated to the mapping of the execution context
+   * - The runtime will be updated to the default runtime of the execution context
+   * - If no class is chosen, try to choose a compatible class
+   * - If the chosen class is compatible with the new selected execution context mapping, do nothing, otherwise, try to choose a compatible class
+   */
+  propagateExecutionContextChange(
+    executionContext: DataSpaceExecutionContext,
+  ): void {
+    const mapping = executionContext.mapping.value;
+    this.changeMapping(mapping);
+    const mappingModelCoverageAnalysisResult =
+      this.dataSpaceAnalysisResult?.mappingToMappingCoverageResult?.get(
+        mapping.path,
+      );
+    if (mappingModelCoverageAnalysisResult) {
+      this.explorerState.mappingModelCoverageAnalysisResult =
+        mappingModelCoverageAnalysisResult;
+    }
+    this.changeRuntime(new RuntimePointer(executionContext.defaultRuntime));
+
+    const compatibleClasses = resolveUsableDataSpaceClasses(
+      this.dataSpace,
+      mapping,
+      this.graphManagerState,
+    );
+    // 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)) {
+      const possibleNewClass = getNullableFirstEntry(compatibleClasses);
+      if (possibleNewClass) {
+        this.changeClass(possibleNewClass);
+      }
+    }
   }
 
   override buildFunctionAnalysisInfo():