@finos/legend-application-query 13.7.2 → 13.7.4

package/src/application/LegendQueryApplicationConfig.ts

@@ -65,8 +65,6 @@ class LegendQueryApplicationCoreOptions {
   TEMPORARY__serviceRegistrationConfig: ServiceRegistrationEnvironmentConfig[] =
     [];
 
-  TEMPORARY__enableMinimalGraph = false;
-
   /**
    * Config specific to query builder
    */
@@ -80,7 +78,6 @@ 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 {
-  type ApplicationPageEntry,
-  type LegendApplicationSetup,
   ActionAlertActionType,
   ActionAlertType,
+  type ApplicationPageEntry,
+  type LegendApplicationSetup,
 } from '@finos/legend-application';
 import { CloneQueryServiceSetup } from './CloneQueryServiceSetup.js';
 import { QueryProductionizerSetup } from './QueryProductionizerSetup.js';
@@ -65,11 +65,9 @@ import {
   generateDataSpaceQuerySetupRoute,
 } from '../__lib__/DSL_DataSpace_LegendQueryNavigation.js';
 import {
-  type QueryBuilderState,
+  QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS,
   type QueryBuilderHeaderActionConfiguration,
   type QueryBuilderMenuActionConfiguration,
-  type QueryBuilderPropagateExecutionContextChangeHelper,
-  QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS,
 } from '@finos/legend-query-builder';
 import {
   ExistingQueryEditorStore,
@@ -77,48 +75,18 @@ import {
 } from '../stores/QueryEditorStore.js';
 import {
   DataSpaceQueryBuilderState,
-  DataSpacesDepotRepository,
   generateDataSpaceTemplateQueryPromotionRoute,
 } from '@finos/legend-extension-dsl-data-space/application';
-import {
-  createGraphBuilderReport,
-  GRAPH_MANAGER_EVENT,
-  LegendSDLC,
-  PackageableElementPointerType,
-  resolvePackagePathAndElementName,
-  RuntimePointer,
-  V1_EngineRuntime,
-  V1_Mapping,
-  V1_PackageableElementPointer,
-  V1_PackageableRuntime,
-  V1_PureGraphManager,
-} from '@finos/legend-graph';
+import { RuntimePointer } from '@finos/legend-graph';
 import { LegendQueryTelemetryHelper } from '../__lib__/LegendQueryTelemetryHelper.js';
-import { resolveVersion, StoreProjectData } from '@finos/legend-server-depot';
-import {
-  ActionState,
-  assertErrorThrown,
-  buildUrl,
-  getNullableFirstEntry,
-  guaranteeNonNullable,
-  guaranteeType,
-  LogEvent,
-  StopWatch,
-  uniq,
-} from '@finos/legend-shared';
+import { StoreProjectData } from '@finos/legend-server-depot';
+import { buildUrl } 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;
@@ -757,246 +725,4 @@ 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,12 +605,6 @@ export const QueryEditor = observer(() => {
       !engineConfig.useClientRequestPayloadCompression,
     );
 
-  const toggleEnableMinialGraphForDataSpaceLoadingPerformance = (): void => {
-    editorStore.setEnableMinialGraphForDataSpaceLoadingPerformance(
-      !editorStore.enableMinialGraphForDataSpaceLoadingPerformance,
-    );
-  };
-
   const TEMPORARY__toggleLightDarkMode = (): void => {
     applicationStore.layoutService.setColorTheme(
       applicationStore.layoutService.TEMPORARY__isLightColorThemeEnabled
@@ -635,11 +629,7 @@ export const QueryEditor = observer(() => {
       applicationStore.alertUnhandledError,
     );
     applicationStore.releaseNotesService.updateViewedVersion();
-  }, [
-    editorStore,
-    applicationStore,
-    editorStore.enableMinialGraphForDataSpaceLoadingPerformance,
-  ]);
+  }, [editorStore, applicationStore]);
 
   return (
     <div className="query-editor">
@@ -686,20 +676,6 @@ 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,15 +25,12 @@ 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 {
@@ -107,7 +104,7 @@ export const TEST__provideMockedQueryEditorStore = (customization?: {
 
 export const TEST__setUpQueryEditor = async (
   MOCK__editorStore: ExistingQueryEditorStore,
-  entities: PlainObject<Entity>[],
+  entities: Entity[],
   lambda: RawLambda,
   mappingPath: string,
   runtimePath: string,
@@ -145,7 +142,7 @@ export const TEST__setUpQueryEditor = async (
   await graphManagerState.initializeSystem();
   await graphManagerState.graphManager.buildGraph(
     graphManagerState.graph,
-    entities as unknown as Entity[],
+    entities,
     graphManagerState.graphBuildState,
   );
 
@@ -165,36 +162,13 @@ 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',
@@ -248,22 +222,16 @@ 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: PlainObject<Entity>[],
-  buildWithMinimalGraph = false,
+  entities: Entity[],
 ): Promise<{
   renderResult: RenderResult;
   queryBuilderState: QueryBuilderState;
 }> => {
-  if (buildWithMinimalGraph) {
-    MOCK__editorStore.applicationStore.config.options.TEMPORARY__enableMinimalGraph =
-      true;
-  }
-
   const projectData = {
     id: 'test-id',
     groupId: 'test.group',
@@ -291,6 +259,11 @@ 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;
@@ -305,22 +278,6 @@ 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',
@@ -328,7 +285,7 @@ export const TEST__setUpDataSpaceExistingQueryEditor = async (
   createSpy(
     MOCK__editorStore.depotServerClient,
     'getEntities',
-  ).mockResolvedValue(buildWithMinimalGraph ? [] : entities);
+  ).mockResolvedValue([]);
   createSpy(
     MOCK__editorStore.depotServerClient,
     'getIndexedDependencyEntities',
@@ -337,10 +294,6 @@ export const TEST__setUpDataSpaceExistingQueryEditor = async (
     MOCK__editorStore.depotServerClient,
     'getEntitiesByClassifier',
   ).mockResolvedValue([]);
-  createSpy(
-    MOCK__editorStore.depotServerClient,
-    'getGenerationContentByPath',
-  ).mockResolvedValue(JSON.stringify(V1_dataspaceAnalyticsResult));
   createSpy(graphManagerState.graphManager, 'getLightQuery').mockResolvedValue(
     lightQuery,
   );
@@ -355,9 +308,10 @@ export const TEST__setUpDataSpaceExistingQueryEditor = async (
   createSpy(graphManagerState.graphManager, 'getQuery').mockResolvedValue(
     query,
   );
-  createSpy(graphManagerState.graphManager, 'getQueryInfo').mockResolvedValue(
-    queryInfo,
-  );
+  createSpy(
+    MOCK__editorStore.depotServerClient,
+    'getGenerationContentByPath',
+  ).mockResolvedValue('');
   createSpy(graphManagerState.graphManager, 'surveyDatasets').mockResolvedValue(
     [],
   );
@@ -371,12 +325,20 @@ 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,18 +15,17 @@
  */
 
 import { LegendApplicationPlugin } from '@finos/legend-application';
+import type { Query } from '@finos/legend-graph';
 import type {
-  QueryBuilder_LegendApplicationPlugin_Extension,
   QueryBuilderState,
+  QueryBuilder_LegendApplicationPlugin_Extension,
 } from '@finos/legend-query-builder';
-import type React from 'react';
 import type { LegendQueryPluginManager } from '../application/LegendQueryPluginManager.js';
-import type {
-  ExistingQueryEditorStore,
-  QueryEditorStore,
+import {
+  type ExistingQueryEditorStore,
+  type QueryEditorStore,
 } from './QueryEditorStore.js';
 import type { QuerySetupLandingPageStore } from './QuerySetupStore.js';
-import type { Query } from '@finos/legend-graph';
 
 export enum QuerySetupActionTag {
   PRODUCTIONIZATION = 'Productionization',