@finos/legend-application-query 13.4.1 → 13.4.2

package/src/components/data-space/DataSpaceQueryCreator.tsx

@@ -0,0 +1,99 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { observer, useLocalObservable } from 'mobx-react-lite';
+import { useApplicationStore } from '@finos/legend-application';
+import { useParams } from '@finos/legend-application/browser';
+import { parseGAVCoordinates } from '@finos/legend-storage';
+import {
+  useLegendQueryApplicationStore,
+  useLegendQueryBaseStore,
+} from '../LegendQueryFrameworkProvider.js';
+import { DataSpaceQueryCreatorStore } from '../../stores/data-space/DataSpaceQueryCreatorStore.js';
+import { QueryEditorStoreContext } from '../QueryEditorStoreProvider.js';
+import {
+  DATA_SPACE_QUERY_CREATOR_QUERY_PARAM_TOKEN,
+  DATA_SPACE_QUERY_CREATOR_ROUTE_PATTERN_TOKEN,
+  type DataSpaceQueryCreatorPathParams,
+} from '../../__lib__/DSL_DataSpace_LegendQueryNavigation.js';
+import { QueryEditor } from '../QueryEditor.js';
+
+const DataSpaceQueryCreatorStoreProvider: React.FC<{
+  children: React.ReactNode;
+  gav: string;
+  dataSpacePath: string;
+  executionContext: string;
+  runtimePath: string | undefined;
+  classPath: string | undefined;
+}> = ({
+  children,
+  gav,
+  dataSpacePath,
+  executionContext,
+  runtimePath,
+  classPath,
+}) => {
+  const { groupId, artifactId, versionId } = parseGAVCoordinates(gav);
+  const applicationStore = useLegendQueryApplicationStore();
+  const baseStore = useLegendQueryBaseStore();
+  const store = useLocalObservable(
+    () =>
+      new DataSpaceQueryCreatorStore(
+        applicationStore,
+        baseStore.depotServerClient,
+        groupId,
+        artifactId,
+        versionId,
+        dataSpacePath,
+        executionContext,
+        runtimePath,
+        classPath,
+      ),
+  );
+  return (
+    <QueryEditorStoreContext.Provider value={store}>
+      {children}
+    </QueryEditorStoreContext.Provider>
+  );
+};
+
+export const DataSpaceQueryCreator = observer(() => {
+  const applicationStore = useApplicationStore();
+  const parameters = useParams<DataSpaceQueryCreatorPathParams>();
+  const gav = parameters[DATA_SPACE_QUERY_CREATOR_ROUTE_PATTERN_TOKEN.GAV];
+  const dataSpacePath =
+    parameters[DATA_SPACE_QUERY_CREATOR_ROUTE_PATTERN_TOKEN.DATA_SPACE_PATH];
+  const executionContext =
+    parameters[DATA_SPACE_QUERY_CREATOR_ROUTE_PATTERN_TOKEN.EXECUTION_CONTEXT];
+  const runtimePath =
+    parameters[DATA_SPACE_QUERY_CREATOR_ROUTE_PATTERN_TOKEN.RUNTIME_PATH];
+  const classPath =
+    applicationStore.navigationService.navigator.getCurrentLocationParameterValue(
+      DATA_SPACE_QUERY_CREATOR_QUERY_PARAM_TOKEN.CLASS_PATH,
+    );
+
+  return (
+    <DataSpaceQueryCreatorStoreProvider
+      gav={gav}
+      dataSpacePath={dataSpacePath}
+      executionContext={executionContext}
+      runtimePath={runtimePath}
+      classPath={classPath}
+    >
+      <QueryEditor />
+    </DataSpaceQueryCreatorStoreProvider>
+  );
+});

package/src/components/data-space/DataSpaceQuerySetup.tsx

@@ -0,0 +1,165 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { observer, useLocalObservable } from 'mobx-react-lite';
+import { useApplicationStore } from '@finos/legend-application';
+import { useEffect, useRef } from 'react';
+import { flowResult } from 'mobx';
+import { QueryBuilderClassSelector } from '@finos/legend-query-builder';
+import {
+  CustomSelectorInput,
+  SearchIcon,
+  type SelectComponent,
+} from '@finos/legend-art';
+import { DataSpaceIcon } from '@finos/legend-extension-dsl-data-space/application';
+import {
+  useLegendQueryApplicationStore,
+  useLegendQueryBaseStore,
+} from '../LegendQueryFrameworkProvider.js';
+import {
+  type DataSpaceQuerySetupState,
+  DataSpaceQuerySetupStore,
+} from '../../stores/data-space/DataSpaceQuerySetupState.js';
+import { QueryEditorStoreContext } from '../QueryEditorStoreProvider.js';
+import { QueryEditor } from '../QueryEditor.js';
+import {
+  DataSpaceAdvancedSearchModal,
+  buildDataSpaceOption,
+  formatDataSpaceOptionLabel,
+  type DataSpaceOption,
+} from '@finos/legend-extension-dsl-data-space/application-query';
+
+const DataSpaceQuerySetupStoreProvider: React.FC<{
+  children: React.ReactNode;
+}> = ({ children }) => {
+  const applicationStore = useLegendQueryApplicationStore();
+  const baseStore = useLegendQueryBaseStore();
+  const store = useLocalObservable(
+    () =>
+      new DataSpaceQuerySetupStore(
+        applicationStore,
+        baseStore.depotServerClient,
+      ),
+  );
+  return (
+    <QueryEditorStoreContext.Provider value={store}>
+      {children}
+    </QueryEditorStoreContext.Provider>
+  );
+};
+
+export const DataSpaceQuerySetup = observer(() => (
+  <DataSpaceQuerySetupStoreProvider>
+    <QueryEditor />
+  </DataSpaceQuerySetupStoreProvider>
+));
+
+/**
+ * This setup panel supports cascading in order: Data-space -> Execution context (-> Runtime) -> Class
+ *
+ * In other words, we will only show:
+ * - For runtime selector: the list of compatible runtimes with the selected execution context mapping
+ * - For class selector: the list of compatible class with the selected execution context mapping
+ *
+ * See details on propagation/cascading in {@link DataSpaceQuerySetupState}
+ */
+const DataSpaceQuerySetupSetupPanelContent = observer(
+  (props: { queryBuilderState: DataSpaceQuerySetupState }) => {
+    const { queryBuilderState } = props;
+    const applicationStore = useApplicationStore();
+    const dataSpaceSearchRef = useRef<SelectComponent>(null);
+    // data space
+    const dataSpaceOptions =
+      queryBuilderState.dataSpaces.map(buildDataSpaceOption);
+    const selectedDataSpaceOption = null;
+    const onDataSpaceOptionChange = (option: DataSpaceOption): void => {
+      queryBuilderState.onDataSpaceChange(option.value);
+    };
+
+    const openDataSpaceAdvancedSearch = (): void =>
+      queryBuilderState.showAdvancedSearchPanel();
+
+    useEffect(() => {
+      flowResult(queryBuilderState.loadDataSpaces()).catch(
+        applicationStore.alertUnhandledError,
+      );
+    }, [queryBuilderState, applicationStore]);
+
+    useEffect(() => dataSpaceSearchRef.current?.focus());
+
+    return (
+      <>
+        <div className="query-builder__setup__config-group">
+          <div className="query-builder__setup__config-group__header">
+            <div className="query-builder__setup__config-group__header__title">
+              data space execution context
+            </div>
+          </div>
+          <div className="query-builder__setup__config-group__content">
+            <div className="query-builder__setup__config-group__item">
+              <div
+                className="btn--sm query-builder__setup__config-group__item__label"
+                title="data space"
+              >
+                <DataSpaceIcon />
+              </div>
+              <CustomSelectorInput
+                ref={dataSpaceSearchRef}
+                className="panel__content__form__section__dropdown query-builder__setup__config-group__item__selector"
+                options={dataSpaceOptions}
+                isLoading={queryBuilderState.loadDataSpacesState.isInProgress}
+                onChange={onDataSpaceOptionChange}
+                value={selectedDataSpaceOption}
+                placeholder="Search for data space..."
+                escapeClearsValue={true}
+                darkMode={
+                  !applicationStore.layoutService
+                    .TEMPORARY__isLightColorThemeEnabled
+                }
+                formatOptionLabel={formatDataSpaceOptionLabel}
+              />
+              <button
+                tabIndex={-1}
+                className="query-builder__setup__data-space-searcher__btn btn--dark"
+                onClick={openDataSpaceAdvancedSearch}
+                title="Open advanced search for data space..."
+              >
+                <SearchIcon />
+              </button>
+              {queryBuilderState.advancedSearchState && (
+                <DataSpaceAdvancedSearchModal
+                  searchState={queryBuilderState.advancedSearchState}
+                  onClose={() => queryBuilderState.hideAdvancedSearchPanel()}
+                />
+              )}
+            </div>
+          </div>
+        </div>
+        <QueryBuilderClassSelector
+          queryBuilderState={queryBuilderState}
+          classes={[]}
+          noMatchMessage="No compatible class found"
+        />
+      </>
+    );
+  },
+);
+
+export const renderDataSpaceQuerySetupSetupPanelContent = (
+  queryBuilderState: DataSpaceQuerySetupState,
+): React.ReactNode => (
+  <DataSpaceQuerySetupSetupPanelContent queryBuilderState={queryBuilderState} />
+);

package/src/components/data-space/DataSpaceTemplateQueryCreator.tsx

@@ -0,0 +1,82 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { observer, useLocalObservable } from 'mobx-react-lite';
+import { useParams } from '@finos/legend-application/browser';
+import { parseGAVCoordinates } from '@finos/legend-storage';
+import {
+  useLegendQueryApplicationStore,
+  useLegendQueryBaseStore,
+} from '../LegendQueryFrameworkProvider.js';
+import { DataSpaceTemplateQueryCreatorStore } from '../../stores/data-space/DataSpaceTemplateQueryCreatorStore.js';
+import { QueryEditorStoreContext } from '../QueryEditorStoreProvider.js';
+import {
+  DATA_SPACE_TEMPLATE_QUERY_CREATOR_ROUTE_PATTERN_TOKEN,
+  type DataSpaceTemplateQueryCreatorPathParams,
+} from '../../__lib__/DSL_DataSpace_LegendQueryNavigation.js';
+import { QueryEditor } from '../QueryEditor.js';
+
+const DataSpaceTemplateQueryCreatorStoreProvider: React.FC<{
+  children: React.ReactNode;
+  gav: string;
+  dataSpacePath: string;
+  templateQueryId: string;
+}> = ({ children, gav, dataSpacePath, templateQueryId }) => {
+  const { groupId, artifactId, versionId } = parseGAVCoordinates(gav);
+  const applicationStore = useLegendQueryApplicationStore();
+  const baseStore = useLegendQueryBaseStore();
+  const store = useLocalObservable(
+    () =>
+      new DataSpaceTemplateQueryCreatorStore(
+        applicationStore,
+        baseStore.depotServerClient,
+        groupId,
+        artifactId,
+        versionId,
+        dataSpacePath,
+        templateQueryId,
+      ),
+  );
+  return (
+    <QueryEditorStoreContext.Provider value={store}>
+      {children}
+    </QueryEditorStoreContext.Provider>
+  );
+};
+
+export const DataSpaceTemplateQueryCreator = observer(() => {
+  const parameters = useParams<DataSpaceTemplateQueryCreatorPathParams>();
+  const gav =
+    parameters[DATA_SPACE_TEMPLATE_QUERY_CREATOR_ROUTE_PATTERN_TOKEN.GAV];
+  const dataSpacePath =
+    parameters[
+      DATA_SPACE_TEMPLATE_QUERY_CREATOR_ROUTE_PATTERN_TOKEN.DATA_SPACE_PATH
+    ];
+  const templateQueryId =
+    parameters[
+      DATA_SPACE_TEMPLATE_QUERY_CREATOR_ROUTE_PATTERN_TOKEN.TEMPLATE_QUERY_ID
+    ];
+
+  return (
+    <DataSpaceTemplateQueryCreatorStoreProvider
+      gav={gav}
+      dataSpacePath={dataSpacePath}
+      templateQueryId={templateQueryId}
+    >
+      <QueryEditor />
+    </DataSpaceTemplateQueryCreatorStoreProvider>
+  );
+});

package/src/components/data-space/QueryDataSpaceUtil.ts

@@ -0,0 +1,34 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+  QUERY_PROFILE_PATH,
+  QUERY_PROFILE_TAG_DATA_SPACE,
+} from '@finos/legend-extension-dsl-data-space/graph';
+import { isValidFullPath, type Query } from '@finos/legend-graph';
+
+export const getDataSpaceQueryInfo = (query: Query): string | undefined => {
+  const dataSpaceTaggedValue = query.taggedValues?.find(
+    (taggedValue) =>
+      taggedValue.profile === QUERY_PROFILE_PATH &&
+      taggedValue.tag === QUERY_PROFILE_TAG_DATA_SPACE &&
+      isValidFullPath(taggedValue.value),
+  );
+  return dataSpaceTaggedValue?.value;
+};
+
+export const isDataSpaceQuery = (query: Query): boolean =>
+  Boolean(getDataSpaceQueryInfo(query));

package/src/stores/LegendQueryApplicationPlugin.ts

@@ -88,11 +88,6 @@ export abstract class LegendQueryApplicationPlugin extends LegendApplicationPlug
     pluginManager.registerApplicationPlugin(this);
   }
 
-  /**
-   * Get Redirect path for root application path
-   */
-  getExtraRootAppRedirectPath?(): string | undefined;
-
   /**
    * Get the list of actions (configurations) for query setup.
    */
@@ -103,27 +98,10 @@ export abstract class LegendQueryApplicationPlugin extends LegendApplicationPlug
    */
   getExtraQueryEditorHelpMenuActionConfigurations?(): QueryEditorHelpMenuActionConfiguration[];
 
-  /**
-   * Get the list of existing query editor state builders.
-   */
-  getExtraExistingQueryEditorStateBuilders?(): ExistingQueryEditorStateBuilder[];
-
   /**
    * Get the list of query editor action renderer configurations.
    */
   getExtraQueryEditorActionConfigurations?(
     editorStore: QueryEditorStore,
   ): QueryEditorActionConfiguration[];
-
-  /**
-   * Get the list of query headers
-   */
-  getExtraQueryHeaders?(): ((
-    editorStore: QueryEditorStore,
-  ) => React.ReactNode | undefined)[];
-
-  /**
-   * Get list of new query navigation paths
-   */
-  getExtraNewQueryNavigationPaths?(): NewQueryNavigationPath[];
 }

package/src/stores/QueryEditorStore.ts

@@ -62,6 +62,7 @@ import {
   reportGraphAnalytics,
   cloneQueryStereotype,
   cloneQueryTaggedValue,
+  type PackageableRuntime,
 } from '@finos/legend-graph';
 import {
   EXTERNAL_APPLICATION_NAVIGATION__generateStudioProjectViewUrl,
@@ -85,6 +86,8 @@ import {
   VersionedProjectData,
 } from '@finos/legend-server-depot';
 import {
+  ActionAlertActionType,
+  ActionAlertType,
   DEFAULT_TAB_SIZE,
   DEFAULT_TYPEAHEAD_SEARCH_MINIMUM_SEARCH_LENGTH,
 } from '@finos/legend-application';
@@ -102,6 +105,20 @@ import {
 } from '@finos/legend-query-builder';
 import { LegendQueryUserDataHelper } from '../__lib__/LegendQueryUserDataHelper.js';
 import { LegendQueryTelemetryHelper } from '../__lib__/LegendQueryTelemetryHelper.js';
+import {
+  DataSpaceProjectInfo,
+  DataSpaceQueryBuilderState,
+  type DataSpaceInfo,
+} from '@finos/legend-extension-dsl-data-space/application';
+import { getDataSpaceQueryInfo } from '../components/data-space/QueryDataSpaceUtil.js';
+import {
+  DSL_DataSpace_getGraphManagerExtension,
+  type DataSpace,
+  type DataSpaceExecutionContext,
+  getOwnDataSpace,
+  retrieveAnalyticsResultCache,
+} from '@finos/legend-extension-dsl-data-space/graph';
+import { generateDataSpaceQueryCreatorRoute } from '../__lib__/DSL_DataSpace_LegendQueryNavigation.js';
 
 export const createViewProjectHandler =
   (applicationStore: LegendQueryApplicationStore) =>
@@ -1034,6 +1051,25 @@ export class ExistingQueryUpdateState {
   }
 }
 
+const resolveExecutionContext = (
+  dataSpace: DataSpace,
+  queryMapping: Mapping,
+  queryRuntime: PackageableRuntime,
+): DataSpaceExecutionContext | undefined => {
+  const matchingExecContexts = dataSpace.executionContexts.filter(
+    (ec) => ec.mapping.value === queryMapping,
+  );
+  if (matchingExecContexts.length > 1) {
+    const matchRuntime = matchingExecContexts.find(
+      (exec) => exec.defaultRuntime.value.path === queryRuntime.path,
+    );
+    // TODO: we will safely do this for now. Long term we should save exec context key into query store
+    // we should make runtime/mapping optional
+    return matchRuntime ?? matchingExecContexts[0];
+  }
+  return matchingExecContexts[0];
+};
+
 export class ExistingQueryEditorStore extends QueryEditorStore {
   private queryId: string;
   private _lightQuery?: LightQuery | undefined;
@@ -1113,6 +1149,154 @@ export class ExistingQueryEditorStore extends QueryEditorStore {
     );
   }
 
+  async buildDataspaceBuilderState(
+    query: Query,
+  ): Promise<DataSpaceQueryBuilderState | undefined> {
+    const dataSpacePath = getDataSpaceQueryInfo(query);
+    if (dataSpacePath) {
+      const dataSpace = getOwnDataSpace(
+        dataSpacePath,
+        this.graphManagerState.graph,
+      );
+      const mapping = query.mapping.value;
+      const matchingExecutionContext = resolveExecutionContext(
+        dataSpace,
+        mapping,
+        query.runtime.value,
+      );
+      if (!matchingExecutionContext) {
+        // if a matching execution context is not found, it means this query is not
+        // properly created from a data space, therefore, we cannot support this case
+        return undefined;
+      }
+      let dataSpaceAnalysisResult;
+      try {
+        const project = StoreProjectData.serialization.fromJson(
+          await this.depotServerClient.getProject(
+            query.groupId,
+            query.artifactId,
+          ),
+        );
+        dataSpaceAnalysisResult = await DSL_DataSpace_getGraphManagerExtension(
+          this.graphManagerState.graphManager,
+        ).retrieveDataSpaceAnalysisFromCache(() =>
+          retrieveAnalyticsResultCache(
+            project,
+            query.versionId,
+            dataSpace.path,
+            this.depotServerClient,
+          ),
+        );
+      } catch {
+        // do nothing
+      }
+      const projectInfo = new DataSpaceProjectInfo(
+        query.groupId,
+        query.artifactId,
+        query.versionId,
+        createViewProjectHandler(this.applicationStore),
+        createViewSDLCProjectHandler(
+          this.applicationStore,
+          this.depotServerClient,
+        ),
+      );
+      const sourceInfo = {
+        groupId: projectInfo.groupId,
+        artifactId: projectInfo.artifactId,
+        versionId: projectInfo.versionId,
+        dataSpace: dataSpace.path,
+      };
+      const dataSpaceQueryBuilderState = new DataSpaceQueryBuilderState(
+        this.applicationStore,
+        this.graphManagerState,
+        this.depotServerClient,
+        dataSpace,
+        matchingExecutionContext,
+        (dataSpaceInfo: DataSpaceInfo) => {
+          if (dataSpaceInfo.defaultExecutionContext) {
+            const proceed = (): void =>
+              this.applicationStore.navigationService.navigator.goToLocation(
+                generateDataSpaceQueryCreatorRoute(
+                  guaranteeNonNullable(dataSpaceInfo.groupId),
+                  guaranteeNonNullable(dataSpaceInfo.artifactId),
+                  LATEST_VERSION_ALIAS, //always default to latest
+                  dataSpaceInfo.path,
+                  guaranteeNonNullable(dataSpaceInfo.defaultExecutionContext),
+                  undefined,
+                  undefined,
+                ),
+              );
+            const updateQueryAndProceed = async (): Promise<void> => {
+              try {
+                await flowResult(
+                  this.updateState.updateQuery(undefined, undefined),
+                );
+                proceed();
+              } catch (error) {
+                assertErrorThrown(error);
+                this.applicationStore.logService.error(
+                  LogEvent.create(LEGEND_QUERY_APP_EVENT.GENERIC_FAILURE),
+                  error,
+                );
+                this.applicationStore.notificationService.notifyError(error);
+              }
+            };
+            if (
+              !query.isCurrentUserQuery ||
+              !this.queryBuilderState?.changeDetectionState.hasChanged
+            ) {
+              proceed();
+            } else {
+              this.applicationStore.alertService.setActionAlertInfo({
+                message: `To change the data space, you need to save the current query
+                   to proceed`,
+                type: ActionAlertType.CAUTION,
+                actions: [
+                  {
+                    label: 'Save query and Proceed',
+                    type: ActionAlertActionType.PROCEED_WITH_CAUTION,
+                    handler: () => {
+                      updateQueryAndProceed().catch(
+                        this.applicationStore.alertUnhandledError,
+                      );
+                    },
+                  },
+                  {
+                    label: 'Abort',
+                    type: ActionAlertActionType.PROCEED,
+                    default: true,
+                  },
+                ],
+              });
+            }
+          } else {
+            this.applicationStore.notificationService.notifyWarning(
+              `Can't switch data space: default execution context not specified`,
+            );
+          }
+        },
+        true,
+        dataSpaceAnalysisResult,
+        undefined,
+        undefined,
+        undefined,
+        projectInfo,
+        this.applicationStore.config.options.queryBuilderConfig,
+        sourceInfo,
+      );
+      const mappingModelCoverageAnalysisResult =
+        dataSpaceAnalysisResult?.executionContextsIndex.get(
+          matchingExecutionContext.name,
+        )?.mappingModelCoverageAnalysisResult;
+      if (mappingModelCoverageAnalysisResult) {
+        dataSpaceQueryBuilderState.explorerState.mappingModelCoverageAnalysisResult =
+          mappingModelCoverageAnalysisResult;
+      }
+      return dataSpaceQueryBuilderState;
+    }
+    return undefined;
+  }
+
   async initializeQueryBuilderState(
     stopWatch: StopWatch,
   ): Promise<QueryBuilderState> {
@@ -1125,18 +1309,6 @@ export class ExistingQueryEditorStore extends QueryEditorStore {
       this.applicationStore.userDataService,
       query.id,
     );
-    let queryBuilderState: QueryBuilderState | undefined;
-    const existingQueryEditorStateBuilders = this.applicationStore.pluginManager
-      .getApplicationPlugins()
-      .flatMap(
-        (plugin) => plugin.getExtraExistingQueryEditorStateBuilders?.() ?? [],
-      );
-    for (const builder of existingQueryEditorStateBuilders) {
-      queryBuilderState = await builder(query, this);
-      if (queryBuilderState) {
-        break;
-      }
-    }
 
     // if no extension found, fall back to basic `class -> mapping -> runtime` mode
     const projectInfo = this.getProjectInfo();
@@ -1145,6 +1317,9 @@ export class ExistingQueryEditorStore extends QueryEditorStore {
       artifactId: projectInfo.artifactId,
       versionId: projectInfo.versionId,
     };
+    let queryBuilderState: QueryBuilderState | undefined =
+      await this.buildDataspaceBuilderState(query);
+
     queryBuilderState =
       queryBuilderState ??
       new ClassQueryBuilderState(