@finos/legend-application-query 13.7.4 → 13.7.6

package/src/application/LegendQueryApplicationConfig.ts

@@ -65,6 +65,8 @@ class LegendQueryApplicationCoreOptions {
   TEMPORARY__serviceRegistrationConfig: ServiceRegistrationEnvironmentConfig[] =
     [];
 
+  TEMPORARY__enableMinimalGraph = false;
+
   /**
    * Config specific to query builder
    */
@@ -78,6 +80,7 @@ class LegendQueryApplicationCoreOptions {
       queryBuilderConfig: optional(
         usingModelSchema(QueryBuilderConfig.serialization.schema),
       ),
+      TEMPORARY__enableMinimalGraph: optional(primitive()),
     }),
   );
 

package/src/components/Core_LegendQueryApplicationPlugin.tsx

@@ -15,9 +15,9 @@
  */
 
 import {
+  type QuerySetupActionConfiguration,
   LegendQueryApplicationPlugin,
   QuerySetupActionTag,
-  type QuerySetupActionConfiguration,
 } from '../stores/LegendQueryApplicationPlugin.js';
 import packageJson from '../../package.json' with { type: 'json' };
 import type { QuerySetupLandingPageStore } from '../stores/QuerySetupStore.js';
@@ -50,10 +50,10 @@ import {
   LEGEND_QUERY_ROUTE_PATTERN,
 } from '../__lib__/LegendQueryNavigation.js';
 import {
-  ActionAlertActionType,
-  ActionAlertType,
   type ApplicationPageEntry,
   type LegendApplicationSetup,
+  ActionAlertActionType,
+  ActionAlertType,
 } from '@finos/legend-application';
 import { CloneQueryServiceSetup } from './CloneQueryServiceSetup.js';
 import { QueryProductionizerSetup } from './QueryProductionizerSetup.js';
@@ -65,9 +65,11 @@ import {
   generateDataSpaceQuerySetupRoute,
 } from '../__lib__/DSL_DataSpace_LegendQueryNavigation.js';
 import {
-  QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS,
+  type QueryBuilderState,
   type QueryBuilderHeaderActionConfiguration,
   type QueryBuilderMenuActionConfiguration,
+  type QueryBuilderPropagateExecutionContextChangeHelper,
+  QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS,
 } from '@finos/legend-query-builder';
 import {
   ExistingQueryEditorStore,
@@ -75,18 +77,48 @@ import {
 } from '../stores/QueryEditorStore.js';
 import {
   DataSpaceQueryBuilderState,
+  DataSpacesDepotRepository,
   generateDataSpaceTemplateQueryPromotionRoute,
 } from '@finos/legend-extension-dsl-data-space/application';
-import { RuntimePointer } from '@finos/legend-graph';
+import {
+  createGraphBuilderReport,
+  GRAPH_MANAGER_EVENT,
+  LegendSDLC,
+  PackageableElementPointerType,
+  resolvePackagePathAndElementName,
+  RuntimePointer,
+  V1_EngineRuntime,
+  V1_Mapping,
+  V1_PackageableElementPointer,
+  V1_PackageableRuntime,
+  V1_PureGraphManager,
+} from '@finos/legend-graph';
 import { LegendQueryTelemetryHelper } from '../__lib__/LegendQueryTelemetryHelper.js';
-import { StoreProjectData } from '@finos/legend-server-depot';
-import { buildUrl } from '@finos/legend-shared';
+import { resolveVersion, StoreProjectData } from '@finos/legend-server-depot';
+import {
+  ActionState,
+  assertErrorThrown,
+  buildUrl,
+  getNullableFirstEntry,
+  guaranteeNonNullable,
+  guaranteeType,
+  LogEvent,
+  StopWatch,
+  uniq,
+} from '@finos/legend-shared';
 import { parseProjectIdentifier } from '@finos/legend-storage';
 import { QueryEditorExistingQueryHeader } from './QueryEditor.js';
 import { DataSpaceTemplateQueryCreatorStore } from '../stores/data-space/DataSpaceTemplateQueryCreatorStore.js';
 import { createViewSDLCProjectHandler } from '../stores/data-space/DataSpaceQueryBuilderHelper.js';
 import { DataSpaceQueryCreatorStore } from '../stores/data-space/DataSpaceQueryCreatorStore.js';
 import { configureCodeEditorComponent } from '@finos/legend-lego/code-editor';
+import {
+  resolveUsableDataSpaceClasses,
+  V1_DataSpace,
+  V1_DataSpaceExecutionContext,
+} from '@finos/legend-extension-dsl-data-space/graph';
+import { flowResult } from 'mobx';
+import { LEGEND_QUERY_APP_EVENT } from '../__lib__/LegendQueryEvent.js';
 
 export class Core_LegendQueryApplicationPlugin extends LegendQueryApplicationPlugin {
   static NAME = packageJson.extensions.applicationQueryPlugin;
@@ -725,4 +757,246 @@ export class Core_LegendQueryApplicationPlugin extends LegendQueryApplicationPlu
       },
     };
   }
+
+  getExtraQueryBuilderPropagateExecutionContextChangeHelper?(): QueryBuilderPropagateExecutionContextChangeHelper[] {
+    return [
+      (
+        queryBuilderState: QueryBuilderState,
+        isGraphBuildingNotRequired?: boolean,
+      ): (() => Promise<void>) | undefined => {
+        /**
+         * 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
+         */
+        const propagateExecutionContextChange = async (): Promise<void> => {
+          const dataSpaceQueryBuilderState = guaranteeType(
+            queryBuilderState,
+            DataSpaceQueryBuilderState,
+          );
+          const mapping =
+            dataSpaceQueryBuilderState.executionContext.mapping.value;
+          const mappingModelCoverageAnalysisResult =
+            dataSpaceQueryBuilderState.dataSpaceAnalysisResult?.mappingToMappingCoverageResult?.get(
+              mapping.path,
+            );
+          const editorStore = (
+            queryBuilderState.workflowState
+              .actionConfig as QueryBuilderActionConfig_QueryApplication
+          ).editorStore;
+          if (
+            dataSpaceQueryBuilderState.dataSpaceAnalysisResult &&
+            mappingModelCoverageAnalysisResult
+          ) {
+            if (
+              !isGraphBuildingNotRequired &&
+              dataSpaceQueryBuilderState.isLightGraphEnabled
+            ) {
+              const supportBuildMinimalGraph =
+                editorStore.applicationStore.config.options
+                  .TEMPORARY__enableMinimalGraph;
+              if (
+                editorStore.enableMinialGraphForDataSpaceLoadingPerformance &&
+                supportBuildMinimalGraph
+              ) {
+                try {
+                  const stopWatch = new StopWatch();
+                  const graph =
+                    dataSpaceQueryBuilderState.graphManagerState.createNewGraph();
+                  const graph_buildReport = createGraphBuilderReport();
+                  const graphManager = guaranteeType(
+                    dataSpaceQueryBuilderState.graphManagerState.graphManager,
+                    V1_PureGraphManager,
+                  );
+                  // 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
+                  const mappingModels = uniq(
+                    Array.from(
+                      dataSpaceQueryBuilderState.dataSpaceAnalysisResult.executionContextsIndex.values(),
+                    ).map((context) => context.mapping),
+                  ).map((m) => {
+                    const _mapping = new V1_Mapping();
+                    const [packagePath, name] =
+                      resolvePackagePathAndElementName(m.path);
+                    _mapping.package = packagePath;
+                    _mapping.name = name;
+                    return graphManager.elementProtocolToEntity(_mapping);
+                  });
+                  const runtimeModels = uniq(
+                    Array.from(
+                      dataSpaceQueryBuilderState.dataSpaceAnalysisResult.executionContextsIndex.values(),
+                    )
+                      .map((context) => context.defaultRuntime)
+                      .concat(
+                        Array.from(
+                          dataSpaceQueryBuilderState.dataSpaceAnalysisResult.executionContextsIndex.values(),
+                        ).flatMap((val) => val.compatibleRuntimes),
+                      ),
+                  ).map((r) => {
+                    const runtime = new V1_PackageableRuntime();
+                    const [packagePath, name] =
+                      resolvePackagePathAndElementName(r.path);
+                    runtime.package = packagePath;
+                    runtime.name = name;
+                    runtime.runtimeValue = new V1_EngineRuntime();
+                    return graphManager.elementProtocolToEntity(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 dataspaceProtocol = new V1_DataSpace();
+                  dataspaceProtocol.name =
+                    dataSpaceQueryBuilderState.dataSpaceAnalysisResult.name;
+                  dataspaceProtocol.package =
+                    dataSpaceQueryBuilderState.dataSpaceAnalysisResult.package;
+                  dataspaceProtocol.supportInfo =
+                    dataSpaceQueryBuilderState.dataSpaceAnalysisResult.supportInfo;
+                  dataspaceProtocol.executionContexts = Array.from(
+                    dataSpaceQueryBuilderState.dataSpaceAnalysisResult
+                      .executionContextsIndex,
+                  ).map(([key, 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.path,
+                    );
+                    contextProtocol.defaultRuntime =
+                      new V1_PackageableElementPointer(
+                        PackageableElementPointerType.RUNTIME,
+                        execContext.defaultRuntime.path,
+                      );
+                    return contextProtocol;
+                  });
+                  dataspaceProtocol.defaultExecutionContext =
+                    dataSpaceQueryBuilderState.dataSpaceAnalysisResult.defaultExecutionContext.name;
+                  dataspaceProtocol.title =
+                    dataSpaceQueryBuilderState.dataSpaceAnalysisResult.title;
+                  dataspaceProtocol.description =
+                    dataSpaceQueryBuilderState.dataSpaceAnalysisResult.description;
+                  const dataspaceEntity =
+                    graphManager.elementProtocolToEntity(dataspaceProtocol);
+
+                  const graphEntities = guaranteeNonNullable(
+                    mappingModelCoverageAnalysisResult.entities,
+                  )
+                    .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) &&
+                        !el.path.startsWith('meta::'),
+                    );
+                  let option;
+                  if (
+                    dataSpaceQueryBuilderState.dataSpaceRepo instanceof
+                    DataSpacesDepotRepository
+                  ) {
+                    option = new LegendSDLC(
+                      dataSpaceQueryBuilderState.dataSpaceRepo.project.groupId,
+                      dataSpaceQueryBuilderState.dataSpaceRepo.project.artifactId,
+                      resolveVersion(
+                        dataSpaceQueryBuilderState.dataSpaceRepo.project
+                          .versionId,
+                      ),
+                    );
+                  }
+                  await dataSpaceQueryBuilderState.graphManagerState.graphManager.buildGraph(
+                    graph,
+                    graphEntities,
+                    ActionState.create(),
+                    option
+                      ? {
+                          origin: option,
+                        }
+                      : {},
+                    graph_buildReport,
+                  );
+                  dataSpaceQueryBuilderState.graphManagerState.graph = graph;
+                  const dependency_buildReport = createGraphBuilderReport();
+                  // report
+                  stopWatch.record(
+                    GRAPH_MANAGER_EVENT.INITIALIZE_GRAPH__SUCCESS,
+                  );
+                  const graphBuilderReportData = {
+                    timings:
+                      dataSpaceQueryBuilderState.applicationStore.timeService.finalizeTimingsRecord(
+                        stopWatch,
+                      ),
+                    dependencies: dependency_buildReport,
+                    dependenciesCount:
+                      dataSpaceQueryBuilderState.graphManagerState.graph
+                        .dependencyManager.numberOfDependencies,
+                    graph: graph_buildReport,
+                  };
+                  editorStore.logBuildGraphMetrics(graphBuilderReportData);
+                  dataSpaceQueryBuilderState.applicationStore.logService.info(
+                    LogEvent.create(
+                      GRAPH_MANAGER_EVENT.INITIALIZE_GRAPH__SUCCESS,
+                    ),
+                    graphBuilderReportData,
+                  );
+                } catch (error) {
+                  assertErrorThrown(error);
+                  editorStore.applicationStore.logService.error(
+                    LogEvent.create(LEGEND_QUERY_APP_EVENT.GENERIC_FAILURE),
+                    error,
+                  );
+                  editorStore.graphManagerState.graph =
+                    editorStore.graphManagerState.createNewGraph();
+                  await flowResult(editorStore.buildFullGraph());
+                }
+              } else {
+                editorStore.graphManagerState.graph =
+                  editorStore.graphManagerState.createNewGraph();
+                await flowResult(editorStore.buildFullGraph());
+              }
+            }
+            dataSpaceQueryBuilderState.explorerState.mappingModelCoverageAnalysisResult =
+              mappingModelCoverageAnalysisResult;
+          }
+          const compatibleClasses = resolveUsableDataSpaceClasses(
+            dataSpaceQueryBuilderState.dataSpace,
+            mapping,
+            dataSpaceQueryBuilderState.graphManagerState,
+            dataSpaceQueryBuilderState,
+          );
+          dataSpaceQueryBuilderState.changeMapping(mapping);
+          dataSpaceQueryBuilderState.changeRuntime(
+            new RuntimePointer(
+              dataSpaceQueryBuilderState.executionContext.defaultRuntime,
+            ),
+          );
+          // if there is no chosen class or the chosen one is not compatible
+          // with the mapping then pick a compatible class if possible
+          if (
+            !dataSpaceQueryBuilderState.class ||
+            !compatibleClasses.includes(dataSpaceQueryBuilderState.class)
+          ) {
+            const possibleNewClass = getNullableFirstEntry(compatibleClasses);
+            if (possibleNewClass) {
+              dataSpaceQueryBuilderState.changeClass(possibleNewClass);
+            }
+          }
+          dataSpaceQueryBuilderState.explorerState.refreshTreeData();
+        };
+        if (
+          queryBuilderState instanceof DataSpaceQueryBuilderState &&
+          queryBuilderState.workflowState.actionConfig instanceof
+            QueryBuilderActionConfig_QueryApplication
+        ) {
+          return propagateExecutionContextChange;
+        }
+        return undefined;
+      },
+    ];
+  }
 }

package/src/components/QueryEditor.tsx

@@ -605,6 +605,12 @@ export const QueryEditor = observer(() => {
       !engineConfig.useClientRequestPayloadCompression,
     );
 
+  const toggleEnableMinialGraphForDataSpaceLoadingPerformance = (): void => {
+    editorStore.setEnableMinialGraphForDataSpaceLoadingPerformance(
+      !editorStore.enableMinialGraphForDataSpaceLoadingPerformance,
+    );
+  };
+
   const TEMPORARY__toggleLightDarkMode = (): void => {
     applicationStore.layoutService.setColorTheme(
       applicationStore.layoutService.TEMPORARY__isLightColorThemeEnabled
@@ -629,7 +635,11 @@ export const QueryEditor = observer(() => {
       applicationStore.alertUnhandledError,
     );
     applicationStore.releaseNotesService.updateViewedVersion();
-  }, [editorStore, applicationStore]);
+  }, [
+    editorStore,
+    applicationStore,
+    editorStore.enableMinialGraphForDataSpaceLoadingPerformance,
+  ]);
 
   return (
     <div className="query-editor">
@@ -676,6 +686,20 @@ export const QueryEditor = observer(() => {
                       Compress request payload
                     </MenuContentItemLabel>
                   </MenuContentItem>
+                  <MenuContentItem
+                    onClick={
+                      toggleEnableMinialGraphForDataSpaceLoadingPerformance
+                    }
+                  >
+                    <MenuContentItemIcon>
+                      {editorStore.enableMinialGraphForDataSpaceLoadingPerformance ? (
+                        <CheckIcon />
+                      ) : null}
+                    </MenuContentItemIcon>
+                    <MenuContentItemLabel>
+                      Enable minimal graph
+                    </MenuContentItemLabel>
+                  </MenuContentItem>
                 </MenuContent>
               }
             >

package/src/components/__test-utils__/QueryEditorComponentTestUtils.tsx

@@ -25,12 +25,15 @@ import { createMock, createSpy } from '@finos/legend-shared/test';
 import {
   type GraphManagerState,
   type RawMappingModelCoverageAnalysisResult,
+  type QueryInfo,
   Query,
   LightQuery,
   RawLambda,
-  PackageableElementExplicitReference,
   QueryExplicitExecutionContext,
   QueryDataSpaceExecutionContext,
+  PackageableElementExplicitReference,
+  QueryDataSpaceExecutionContextInfo,
+  QueryExplicitExecutionContextInfo,
 } from '@finos/legend-graph';
 import { DepotServerClient } from '@finos/legend-server-depot';
 import {
@@ -40,7 +43,11 @@ import {
 import { TEST__getTestLegendQueryApplicationConfig } from '../../stores/__test-utils__/LegendQueryApplicationTestUtils.js';
 import { LegendQueryPluginManager } from '../../application/LegendQueryPluginManager.js';
 import { ExistingQueryEditor } from '../QueryEditor.js';
-import type { EntitiesWithOrigin, Entity } from '@finos/legend-storage';
+import type {
+  EntitiesWithOrigin,
+  Entity,
+  StoredFileGeneration,
+} from '@finos/legend-storage';
 import { ExistingQueryEditorStore } from '../../stores/QueryEditorStore.js';
 import type { LegendQueryApplicationStore } from '../../stores/LegendQueryBaseStore.js';
 import {
@@ -104,7 +111,7 @@ export const TEST__provideMockedQueryEditorStore = (customization?: {
 
 export const TEST__setUpQueryEditor = async (
   MOCK__editorStore: ExistingQueryEditorStore,
-  entities: Entity[],
+  entities: PlainObject<Entity>[],
   lambda: RawLambda,
   mappingPath: string,
   runtimePath: string,
@@ -142,7 +149,7 @@ export const TEST__setUpQueryEditor = async (
   await graphManagerState.initializeSystem();
   await graphManagerState.graphManager.buildGraph(
     graphManagerState.graph,
-    entities,
+    entities as unknown as Entity[],
     graphManagerState.graphBuildState,
   );
 
@@ -162,13 +169,36 @@ export const TEST__setUpQueryEditor = async (
   );
   query.executionContext = execContext;
   query.content = 'some content';
+
+  const execContextInfo = new QueryExplicitExecutionContextInfo();
+  execContextInfo.mapping = mappingPath;
+  execContextInfo.runtime = runtimePath;
+
+  const queryInfo: QueryInfo = {
+    name: TEST_QUERY_NAME,
+    id: TEST_QUERY_ID,
+    versionId: '0.0.0',
+    groupId: 'test.group',
+    artifactId: 'test-artifact',
+    executionContext: execContextInfo,
+    content: 'some content',
+    isCurrentUserQuery: true,
+  };
+
   createSpy(
     MOCK__editorStore.depotServerClient,
     'getProject',
   ).mockResolvedValue(projectData);
+  createSpy(
+    MOCK__editorStore.depotServerClient,
+    'getEntities',
+  ).mockResolvedValue(entities);
   createSpy(graphManagerState.graphManager, 'getLightQuery').mockResolvedValue(
     lightQuery,
   );
+  createSpy(graphManagerState.graphManager, 'getQueryInfo').mockResolvedValue(
+    queryInfo,
+  );
   createSpy(
     graphManagerState.graphManager,
     'pureCodeToLambda',
@@ -222,16 +252,23 @@ export const TEST__setUpQueryEditor = async (
 
 export const TEST__setUpDataSpaceExistingQueryEditor = async (
   MOCK__editorStore: ExistingQueryEditorStore,
-  v1_dataspaceAnalyticsResult: PlainObject<V1_DataSpaceAnalysisResult>,
+  V1_dataspaceAnalyticsResult: PlainObject<V1_DataSpaceAnalysisResult>,
   dataSpacePath: string,
   executionContext: string,
   lambda: RawLambda,
   mappingPath: string,
-  entities: Entity[],
+  entities: PlainObject<Entity>[],
+  buildWithMinimalGraph = false,
+  V1_dataspaceArtifacts: PlainObject<StoredFileGeneration>[] = [],
 ): Promise<{
   renderResult: RenderResult;
   queryBuilderState: QueryBuilderState;
 }> => {
+  if (buildWithMinimalGraph) {
+    MOCK__editorStore.applicationStore.config.options.TEMPORARY__enableMinimalGraph =
+      true;
+  }
+
   const projectData = {
     id: 'test-id',
     groupId: 'test.group',
@@ -259,11 +296,6 @@ export const TEST__setUpDataSpaceExistingQueryEditor = async (
   });
 
   await graphManagerState.initializeSystem();
-  await graphManagerState.graphManager.buildGraph(
-    graphManagerState.graph,
-    entities,
-    graphManagerState.graphBuildState,
-  );
 
   const query = new Query();
   query.name = lightQuery.name;
@@ -278,6 +310,22 @@ export const TEST__setUpDataSpaceExistingQueryEditor = async (
   execContext.executionKey = executionContext;
   query.executionContext = execContext;
   query.content = 'some content';
+
+  const execContextInfo = new QueryDataSpaceExecutionContextInfo();
+  execContextInfo.dataSpacePath = dataSpacePath;
+  execContextInfo.executionKey = executionContext;
+
+  const queryInfo: QueryInfo = {
+    name: TEST_QUERY_NAME,
+    id: TEST_QUERY_ID,
+    versionId: '0.0.0',
+    groupId: 'test.group',
+    artifactId: 'test-artifact',
+    executionContext: execContextInfo,
+    content: 'some content',
+    isCurrentUserQuery: true,
+  };
+
   createSpy(
     MOCK__editorStore.depotServerClient,
     'getProject',
@@ -285,7 +333,7 @@ export const TEST__setUpDataSpaceExistingQueryEditor = async (
   createSpy(
     MOCK__editorStore.depotServerClient,
     'getEntities',
-  ).mockResolvedValue([]);
+  ).mockResolvedValue(buildWithMinimalGraph ? [] : entities);
   createSpy(
     MOCK__editorStore.depotServerClient,
     'getIndexedDependencyEntities',
@@ -294,6 +342,14 @@ export const TEST__setUpDataSpaceExistingQueryEditor = async (
     MOCK__editorStore.depotServerClient,
     'getEntitiesByClassifier',
   ).mockResolvedValue([]);
+  createSpy(
+    MOCK__editorStore.depotServerClient,
+    'getGenerationContentByPath',
+  ).mockResolvedValue(JSON.stringify(V1_dataspaceAnalyticsResult));
+  createSpy(
+    MOCK__editorStore.depotServerClient,
+    'getGenerationFilesByType',
+  ).mockResolvedValue(V1_dataspaceArtifacts);
   createSpy(graphManagerState.graphManager, 'getLightQuery').mockResolvedValue(
     lightQuery,
   );
@@ -308,10 +364,9 @@ export const TEST__setUpDataSpaceExistingQueryEditor = async (
   createSpy(graphManagerState.graphManager, 'getQuery').mockResolvedValue(
     query,
   );
-  createSpy(
-    MOCK__editorStore.depotServerClient,
-    'getGenerationContentByPath',
-  ).mockResolvedValue('');
+  createSpy(graphManagerState.graphManager, 'getQueryInfo').mockResolvedValue(
+    queryInfo,
+  );
   createSpy(graphManagerState.graphManager, 'surveyDatasets').mockResolvedValue(
     [],
   );
@@ -325,20 +380,12 @@ export const TEST__setUpDataSpaceExistingQueryEditor = async (
   );
   const dataspaceAnalyticsResult =
     await graphManagerExtension.buildDataSpaceAnalytics(
-      v1_dataspaceAnalyticsResult,
+      V1_dataspaceAnalyticsResult,
       graphManagerState.graphManager.pluginManager.getPureProtocolProcessorPlugins(),
     );
   createSpy(graphManagerExtension, 'analyzeDataSpace').mockResolvedValue(
     dataspaceAnalyticsResult,
   );
-  const mappingAnalyticsResult =
-    dataspaceAnalyticsResult.mappingToMappingCoverageResult?.get(mappingPath);
-  if (mappingAnalyticsResult) {
-    createSpy(
-      graphManagerState.graphManager,
-      'analyzeMappingModelCoverage',
-    ).mockResolvedValue(mappingAnalyticsResult);
-  }
 
   MOCK__editorStore.buildGraph = createMock();
   graphManagerState.graphManager.initialize = createMock();

package/src/stores/LegendQueryApplicationPlugin.tsx

@@ -15,17 +15,18 @@
  */
 
 import { LegendApplicationPlugin } from '@finos/legend-application';
-import type { Query } from '@finos/legend-graph';
 import type {
-  QueryBuilderState,
   QueryBuilder_LegendApplicationPlugin_Extension,
+  QueryBuilderState,
 } from '@finos/legend-query-builder';
+import type React from 'react';
 import type { LegendQueryPluginManager } from '../application/LegendQueryPluginManager.js';
-import {
-  type ExistingQueryEditorStore,
-  type QueryEditorStore,
+import type {
+  ExistingQueryEditorStore,
+  QueryEditorStore,
 } from './QueryEditorStore.js';
 import type { QuerySetupLandingPageStore } from './QuerySetupStore.js';
+import type { Query } from '@finos/legend-graph';
 
 export enum QuerySetupActionTag {
   PRODUCTIONIZATION = 'Productionization',