@finos/legend-extension-dsl-data-space 10.3.86 → 10.4.1

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

@@ -19,6 +19,8 @@ import {
   type AbstractPureGraphManager,
   type PureProtocolProcessorPlugin,
   type MappingModelCoverageAnalysisResult,
+  type GraphManagerOperationReport,
+  type FunctionAnalysisInfo,
   PureModel,
   V1_PureGraphManager,
   PureClientVersion,
@@ -36,8 +38,13 @@ import {
   V1_deserializePackageableElement,
   QueryDataSpaceExecutionContextInfo,
   V1_RemoteEngine,
+  LegendSDLC,
+  PackageableElementPointerType,
+  V1_PackageableElementPointer,
+  V1_ConcreteFunctionDefinition,
+  V1_buildFunctionInfoAnalysis,
 } from '@finos/legend-graph';
-import type { Entity } from '@finos/legend-storage';
+import type { Entity, ProjectGAVCoordinates } from '@finos/legend-storage';
 import {
   type PlainObject,
   ActionState,
@@ -56,6 +63,7 @@ import {
 } from '../../../../graph/metamodel/pure/model/packageableElements/dataSpace/DSL_DataSpace_DataSpace.js';
 import {
   V1_DataSpace,
+  V1_DataSpaceExecutionContext,
   V1_DataSpaceSupportCombinedInfo,
   V1_DataSpaceSupportEmail,
   V1_DataSpaceTemplateExecutable,
@@ -96,6 +104,7 @@ 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.';
@@ -219,6 +228,112 @@ 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,
@@ -255,11 +370,78 @@ 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(
-    json: PlainObject<V1_DataSpaceAnalysisResult>,
+    analytics: 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(json, plugins);
+    const analysisResult = V1_deserializeDataSpaceAnalysisResult(
+      analytics,
+      plugins,
+    );
     const result = new DataSpaceAnalysisResult();
     result.name = analysisResult.name;
     result.package = analysisResult.package;
@@ -306,26 +488,30 @@ 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
     }
 
-    // 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(),
-    );
-
+    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 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
@@ -355,55 +541,142 @@ export class V1_DSL_DataSpace_PureGraphManagerExtension extends DSL_DataSpace_Pu
       return runtime;
     });
 
-    // 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 [];
-          }),
-        )
-          // 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(),
+    // 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),
+        )
+        .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(),
+      );
+    }
 
     const mappingToMappingCoverageResult = new Map<
       string,
@@ -414,7 +687,11 @@ export class V1_DSL_DataSpace_PureGraphManagerExtension extends DSL_DataSpace_Pu
         ([key, value]) => {
           mappingToMappingCoverageResult.set(
             key,
-            V1_buildModelCoverageAnalysisResult(value, graph.getMapping(key)),
+            V1_buildModelCoverageAnalysisResult(
+              value,
+              this.graphManager,
+              graph.getMapping(key),
+            ),
           );
         },
       );
@@ -455,6 +732,7 @@ export class V1_DSL_DataSpace_PureGraphManagerExtension extends DSL_DataSpace_Pu
           context.mapping,
           V1_buildModelCoverageAnalysisResult(
             context.mappingModelCoverageAnalysisResult,
+            this.graphManager,
             contextAnalysisResult.mapping,
           ),
         );
@@ -586,13 +864,15 @@ export class V1_DSL_DataSpace_PureGraphManagerExtension extends DSL_DataSpace_Pu
     });
 
     // diagrams
-    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;
-    });
+    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;
+      },
+    );
 
     // executables
     result.executables = analysisResult.executables.map(

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

@@ -34,7 +34,6 @@ import {
   Package,
   QueryDataSpaceExecutionContext,
   elementBelongsToPackage,
-  RuntimePointer,
 } from '@finos/legend-graph';
 import {
   type DepotServerClient,
@@ -47,7 +46,6 @@ import {
   ActionState,
   assertErrorThrown,
   filterByType,
-  getNullableFirstEntry,
 } from '@finos/legend-shared';
 import { action, flow, makeObservable, observable } from 'mobx';
 import { renderDataSpaceQueryBuilderSetupPanelContent } from '../../components/query-builder/DataSpaceQueryBuilder.js';
@@ -88,11 +86,34 @@ export const resolveUsableDataSpaceClasses = (
   dataSpace: DataSpace,
   mapping: Mapping,
   graphManagerState: GraphManagerState,
+  queryBuilderState?: DataSpaceQueryBuilderState,
 ): Class[] => {
-  const compatibleClasses = getMappingCompatibleClasses(
+  let 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) => {
@@ -335,7 +356,7 @@ export class DataSpacesDepotRepository extends DataSpacesBuilderRepoistory {
 }
 
 export class DataSpaceQueryBuilderState extends QueryBuilderState {
-  readonly onDataSpaceChange: (val: DataSpaceInfo) => void;
+  readonly onDataSpaceChange: (val: DataSpaceInfo) => Promise<void>;
   readonly onExecutionContextChange?:
     | ((val: DataSpaceExecutionContext) => void)
     | undefined;
@@ -351,6 +372,7 @@ export class DataSpaceQueryBuilderState extends QueryBuilderState {
   executionContext!: DataSpaceExecutionContext;
   showRuntimeSelector = false;
   isTemplateQueryDialogOpen = false;
+  isLightGraphEnabled!: boolean;
   displayedTemplateQueries: DataSpaceExecutableAnalysisResult[] | undefined;
 
   constructor(
@@ -360,8 +382,9 @@ export class DataSpaceQueryBuilderState extends QueryBuilderState {
     actionConfig: QueryBuilderActionConfig,
     dataSpace: DataSpace,
     executionContext: DataSpaceExecutionContext,
+    isLightGraphEnabled: boolean,
     dataSpaceRepo: DataSpacesBuilderRepoistory | undefined,
-    onDataSpaceChange: (val: DataSpaceInfo) => void,
+    onDataSpaceChange: (val: DataSpaceInfo) => Promise<void>,
     dataSpaceAnalysisResult?: DataSpaceAnalysisResult | undefined,
     onExecutionContextChange?:
       | ((val: DataSpaceExecutionContext) => void)
@@ -377,10 +400,12 @@ 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,
     });
 
@@ -425,41 +450,8 @@ export class DataSpaceQueryBuilderState extends QueryBuilderState {
     this.showRuntimeSelector = 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);
-      }
-    }
+  setIsLightGraphEnabled(val: boolean): void {
+    this.isLightGraphEnabled = val;
   }
 
   override buildFunctionAnalysisInfo():