@finos/legend-extension-dsl-data-space 10.1.17 → 10.1.18

package/src/components/query/DataSpaceQueryBuilder.tsx

@@ -30,7 +30,10 @@ import {
 } from '@finos/legend-art';
 import { observer } from 'mobx-react-lite';
 import { useApplicationStore } from '@finos/legend-application';
-import type { DataSpaceQueryBuilderState } from '../../stores/query/DataSpaceQueryBuilderState.js';
+import {
+  DataSpaceQueryBuilderState,
+  resolveUsableDataSpaceClasses,
+} from '../../stores/query/DataSpaceQueryBuilderState.js';
 import {
   buildRuntimeValueOption,
   getRuntimeOptionFormatter,
@@ -38,32 +41,22 @@ import {
 } from '@finos/legend-query-builder';
 import {
   type Runtime,
-  type GraphManagerState,
-  type Mapping,
-  getMappingCompatibleClasses,
   getMappingCompatibleRuntimes,
   PackageableElementExplicitReference,
   RuntimePointer,
-  Class,
-  Package,
-  getDescendantsOfPackage,
 } from '@finos/legend-graph';
 import type { DataSpaceInfo } from '../../stores/query/DataSpaceInfo.js';
 import { generateGAVCoordinates } from '@finos/legend-storage';
 import { useEffect, useMemo, useState } from 'react';
-import {
-  debounce,
-  filterByType,
-  guaranteeType,
-  uniq,
-} from '@finos/legend-shared';
+import { debounce, guaranteeType } from '@finos/legend-shared';
 import { flowResult } from 'mobx';
-import type {
+import {
   DataSpace,
-  DataSpaceExecutionContext,
+  type DataSpaceExecutionContext,
 } from '../../graph/metamodel/pure/model/packageableElements/dataSpace/DSL_DataSpace_DataSpace.js';
 import { DataSpaceIcon } from '../DSL_DataSpace_Icon.js';
 import { DataSpaceAdvancedSearchModal } from './DataSpaceAdvancedSearchModal.js';
+import type { EditorStore } from '@finos/legend-application-studio';
 
 export type DataSpaceOption = {
   label: string;
@@ -80,11 +73,15 @@ export const formatDataSpaceOptionLabel = (
 ): React.ReactNode => (
   <div
     className="query-builder__setup__data-space__option"
-    title={`${option.label} - ${option.value.path} - ${generateGAVCoordinates(
-      option.value.groupId,
-      option.value.artifactId,
-      option.value.versionId,
-    )}`}
+    title={`${option.label} - ${option.value.path} - ${
+      option.value.groupId && option.value.artifactId && option.value.versionId
+        ? generateGAVCoordinates(
+            option.value.groupId,
+            option.value.artifactId,
+            option.value.versionId,
+          )
+        : ''
+    }`}
   >
     <div className="query-builder__setup__data-space__option__label">
       {option.label}
@@ -93,34 +90,21 @@ export const formatDataSpaceOptionLabel = (
       {option.value.path}
     </div>
     <div className="query-builder__setup__data-space__option__gav">
-      {generateGAVCoordinates(
-        option.value.groupId,
-        option.value.artifactId,
-        option.value.versionId,
-      )}
+      {option.value.groupId &&
+        option.value.artifactId &&
+        option.value.versionId && (
+          <>
+            {generateGAVCoordinates(
+              option.value.groupId,
+              option.value.artifactId,
+              option.value.versionId,
+            )}
+          </>
+        )}
     </div>
   </div>
 );
 
-const resolveDataSpaceClasses = (
-  dataSpace: DataSpace,
-  mapping: Mapping,
-  graphManagerState: GraphManagerState,
-): Class[] => {
-  if (dataSpace.elements?.length) {
-    const dataSpaceElements = dataSpace.elements.map((ep) => ep.element.value);
-    return uniq([
-      ...dataSpaceElements.filter(filterByType(Class)),
-      ...dataSpaceElements
-        .filter(filterByType(Package))
-        .map((_package) => Array.from(getDescendantsOfPackage(_package)))
-        .flat()
-        .filter(filterByType(Class)),
-    ]);
-  }
-  return getMappingCompatibleClasses(mapping, graphManagerState.usableClasses);
-};
-
 type ExecutionContextOption = {
   label: string;
   value: DataSpaceExecutionContext;
@@ -154,9 +138,9 @@ const DataSpaceQueryBuilderSetupPanelContent = observer(
       label:
         queryBuilderState.dataSpace.title ?? queryBuilderState.dataSpace.name,
       value: {
-        groupId: queryBuilderState.groupId,
-        artifactId: queryBuilderState.artifactId,
-        versionId: queryBuilderState.versionId,
+        groupId: queryBuilderState.projectInfo?.groupId,
+        artifactId: queryBuilderState.projectInfo?.artifactId,
+        versionId: queryBuilderState.projectInfo?.versionId,
         title: queryBuilderState.dataSpace.title,
         name: queryBuilderState.dataSpace.name,
         path: queryBuilderState.dataSpace.path,
@@ -241,7 +225,7 @@ const DataSpaceQueryBuilderSetupPanelContent = observer(
     });
 
     // class
-    const classes = resolveDataSpaceClasses(
+    const classes = resolveUsableDataSpaceClasses(
       queryBuilderState.dataSpace,
       queryBuilderState.executionContext.mapping.value,
       queryBuilderState.graphManagerState,
@@ -408,3 +392,47 @@ export const renderDataSpaceQueryBuilderSetupPanelContent = (
     queryBuilderState={queryBuilderState}
   />
 );
+
+export const queryDataSpace = async (
+  dataSpace: DataSpace,
+  editorStore: EditorStore,
+): Promise<void> => {
+  const embeddedQueryBuilderState = editorStore.embeddedQueryBuilderState;
+  await flowResult(
+    embeddedQueryBuilderState.setEmbeddedQueryBuilderConfiguration({
+      setupQueryBuilderState: () => {
+        const queryBuilderState = new DataSpaceQueryBuilderState(
+          editorStore.applicationStore,
+          editorStore.graphManagerState,
+          editorStore.depotServerClient,
+          dataSpace,
+          dataSpace.defaultExecutionContext,
+          (dataSpaceInfo: DataSpaceInfo) => {
+            queryBuilderState.dataSpace = guaranteeType(
+              queryBuilderState.graphManagerState.graph.getElement(
+                dataSpaceInfo.path,
+              ),
+              DataSpace,
+            );
+            queryBuilderState.setExecutionContext(
+              queryBuilderState.dataSpace.defaultExecutionContext,
+            );
+            queryBuilderState.propagateExecutionContextChange(
+              queryBuilderState.dataSpace.defaultExecutionContext,
+            );
+          },
+          false,
+        );
+        queryBuilderState.setExecutionContext(
+          dataSpace.defaultExecutionContext,
+        );
+        queryBuilderState.propagateExecutionContextChange(
+          dataSpace.defaultExecutionContext,
+        );
+        return queryBuilderState;
+      },
+      actionConfigs: [],
+      disableCompile: true,
+    }),
+  );
+};

package/src/components/studio/DSL_DataSpace_LegendStudioApplicationPlugin.tsx

@@ -56,6 +56,7 @@ import {
   DataSpacePreviewAction,
 } from './DataSpacePreviewAction.js';
 import type { PureGrammarTextSuggestion } from '@finos/legend-lego/code-editor';
+import { DataSpaceQueryAction } from './DataSpaceQueryAction.js';
 
 const DATA_SPACE_ELEMENT_TYPE = 'DATA SPACE';
 const DATA_SPACE_ELEMENT_PROJECT_EXPLORER_DND_TYPE =
@@ -81,6 +82,15 @@ export class DSL_DataSpace_LegendStudioApplicationPlugin
 
   override getExtraExplorerContextMenuItemRendererConfigurations(): ExplorerContextMenuItemRendererConfiguration[] {
     return [
+      {
+        key: 'data-space-query',
+        renderer: (editorStore, element) => {
+          if (element instanceof DataSpace) {
+            return <DataSpaceQueryAction dataSpace={element} />;
+          }
+          return undefined;
+        },
+      },
       {
         key: 'data-space-preview',
         renderer: (editorStore, element) => {

package/src/components/studio/DataSpaceQueryAction.tsx

@@ -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 { MenuContentItem } from '@finos/legend-art';
+import { observer } from 'mobx-react-lite';
+import type { DataSpace } from '../../graph/metamodel/pure/model/packageableElements/dataSpace/DSL_DataSpace_DataSpace.js';
+import { useEditorStore } from '@finos/legend-application-studio';
+import { queryDataSpace } from '../query/DataSpaceQueryBuilder.js';
+
+export const DataSpaceQueryAction = observer(
+  (props: { dataSpace: DataSpace }) => {
+    const { dataSpace } = props;
+    const editorStore = useEditorStore();
+    const buildQuery = editorStore.applicationStore.guardUnhandledError(
+      async () => {
+        await queryDataSpace(dataSpace, editorStore);
+      },
+    );
+    return <MenuContentItem onClick={buildQuery}>Query...</MenuContentItem>;
+  },
+);

package/src/stores/query/DataSpaceAdvancedSearchState.ts

@@ -32,6 +32,7 @@ import {
   type PlainObject,
   ActionState,
   assertErrorThrown,
+  guaranteeNonNullable,
 } from '@finos/legend-shared';
 import { action, flow, flowResult, makeObservable, observable } from 'mobx';
 import { DSL_DataSpace_getGraphManagerExtension } from '../../graph-manager/protocol/pure/DSL_DataSpace_PureGraphManagerExtension.js';
@@ -157,16 +158,15 @@ export class DataSpaceAdvancedSearchState {
   *loadDataSpace(dataSpace: DataSpaceInfo): GeneratorFn<void> {
     this.loadDataSpaceState.inProgress();
     this.loadDataSpaceState.setMessage(`Initializing...`);
-
     try {
+      const groupId = guaranteeNonNullable(dataSpace.groupId);
+      const artifactId = guaranteeNonNullable(dataSpace.artifactId);
+      const versionId = guaranteeNonNullable(dataSpace.versionId);
       // fetch project
       this.loadDataSpaceState.setMessage(`Fetching project...`);
       const project = StoreProjectData.serialization.fromJson(
         (yield flowResult(
-          this.depotServerClient.getProject(
-            dataSpace.groupId,
-            dataSpace.artifactId,
-          ),
+          this.depotServerClient.getProject(groupId, artifactId),
         )) as PlainObject<StoreProjectData>,
       );
       // analyze data space
@@ -177,13 +177,13 @@ export class DataSpaceAdvancedSearchState {
         () =>
           retrieveProjectEntitiesWithDependencies(
             project,
-            dataSpace.versionId,
+            versionId,
             this.depotServerClient,
           ),
         () =>
           retrieveAnalyticsResultCache(
             project,
-            dataSpace.versionId,
+            versionId,
             dataSpace.path,
             this.depotServerClient,
           ),
@@ -192,45 +192,36 @@ export class DataSpaceAdvancedSearchState {
       this.dataSpaceViewerState = new DataSpaceViewerState(
         this.applicationStore,
         this.graphManagerState,
-        dataSpace.groupId,
-        dataSpace.artifactId,
-        dataSpace.versionId,
+        groupId,
+        artifactId,
+        versionId,
         analysisResult,
         {
           retrieveGraphData: () =>
             new GraphDataWithOrigin(
-              new LegendSDLC(
-                dataSpace.groupId,
-                dataSpace.artifactId,
-                dataSpace.versionId,
-              ),
+              new LegendSDLC(groupId, artifactId, versionId),
             ),
           queryDataSpace: (executionContextKey: string) =>
             generateDataSpaceQueryCreatorRoute(
-              dataSpace.groupId,
-              dataSpace.artifactId,
-              dataSpace.versionId,
+              groupId,
+              artifactId,
+              versionId,
               analysisResult.path,
               executionContextKey,
             ),
           viewProject: (path: string | undefined) =>
-            this.viewProject(
-              dataSpace.groupId,
-              dataSpace.artifactId,
-              dataSpace.versionId,
-              path,
-            ),
+            this.viewProject(groupId, artifactId, versionId, path),
           viewSDLCProject: (path: string | undefined) =>
-            this.viewSDLCProject(dataSpace.groupId, dataSpace.artifactId, path),
+            this.viewSDLCProject(groupId, artifactId, path),
           queryClass: (_class: Class): void => {
             this.proceedToCreateQuery(_class);
           },
           openServiceQuery: (servicePath: string): void =>
             this.applicationStore.navigationService.navigator.visitAddress(
               generateServiceQueryCreatorRoute(
-                dataSpace.groupId,
-                dataSpace.artifactId,
-                dataSpace.versionId,
+                groupId,
+                artifactId,
+                versionId,
                 servicePath,
               ),
             ),

package/src/stores/query/DataSpaceInfo.ts

@@ -22,9 +22,9 @@ import { isString } from '@finos/legend-shared';
 import { extractEntityNameFromPath } from '@finos/legend-storage';
 
 export interface DataSpaceInfo {
-  groupId: string;
-  artifactId: string;
-  versionId: string;
+  groupId: string | undefined;
+  artifactId: string | undefined;
+  versionId: string | undefined;
   title: string | undefined;
   name: string;
   path: string;

package/src/stores/query/DataSpaceQueryBuilderState.ts

@@ -25,7 +25,10 @@ import {
   getMappingCompatibleClasses,
   RuntimePointer,
   type Runtime,
-  type Class,
+  Class,
+  type Mapping,
+  getDescendantsOfPackage,
+  Package,
 } from '@finos/legend-graph';
 import {
   DepotScope,
@@ -38,21 +41,40 @@ import {
   ActionState,
   assertErrorThrown,
   getNullableFirstEntry,
+  filterByType,
+  uniq,
 } from '@finos/legend-shared';
 import { action, flow, makeObservable, observable } from 'mobx';
 import { renderDataSpaceQueryBuilderSetupPanelContent } from '../../components/query/DataSpaceQueryBuilder.js';
-import type {
+import {
   DataSpace,
-  DataSpaceExecutionContext,
+  type DataSpaceExecutionContext,
 } from '../../graph/metamodel/pure/model/packageableElements/dataSpace/DSL_DataSpace_DataSpace.js';
 import { DATA_SPACE_ELEMENT_CLASSIFIER_PATH } from '../../graph-manager/protocol/pure/DSL_DataSpace_PureProtocolProcessorPlugin.js';
 import { type DataSpaceInfo, extractDataSpaceInfo } from './DataSpaceInfo.js';
 import { DataSpaceAdvancedSearchState } from './DataSpaceAdvancedSearchState.js';
 import type { DataSpaceAnalysisResult } from '../../graph-manager/action/analytics/DataSpaceAnalysis.js';
 
-export class DataSpaceQueryBuilderState extends QueryBuilderState {
-  readonly depotServerClient: DepotServerClient;
-  readonly dataSpace: DataSpace;
+export const resolveUsableDataSpaceClasses = (
+  dataSpace: DataSpace,
+  mapping: Mapping,
+  graphManagerState: GraphManagerState,
+): Class[] => {
+  if (dataSpace.elements?.length) {
+    const dataSpaceElements = dataSpace.elements.map((ep) => ep.element.value);
+    return uniq([
+      ...dataSpaceElements.filter(filterByType(Class)),
+      ...dataSpaceElements
+        .filter(filterByType(Package))
+        .map((_package) => Array.from(getDescendantsOfPackage(_package)))
+        .flat()
+        .filter(filterByType(Class)),
+    ]);
+  }
+  return getMappingCompatibleClasses(mapping, graphManagerState.usableClasses);
+};
+
+export class DataSpaceProjectInfo {
   readonly groupId: string;
   readonly artifactId: string;
   readonly versionId: string;
@@ -67,6 +89,33 @@ export class DataSpaceQueryBuilderState extends QueryBuilderState {
     artifactId: string,
     entityPath: string | undefined,
   ) => Promise<void>;
+
+  constructor(
+    groupId: string,
+    artifactId: string,
+    versionId: string,
+    viewProject: (
+      groupId: string,
+      artifactId: string,
+      versionId: string,
+      entityPath: string | undefined,
+    ) => void,
+    viewSDLCProject: (
+      groupId: string,
+      artifactId: string,
+      entityPath: string | undefined,
+    ) => Promise<void>,
+  ) {
+    this.groupId = groupId;
+    this.artifactId = artifactId;
+    this.versionId = versionId;
+    this.viewProject = viewProject;
+    this.viewSDLCProject = viewSDLCProject;
+  }
+}
+
+export class DataSpaceQueryBuilderState extends QueryBuilderState {
+  readonly depotServerClient: DepotServerClient;
   readonly isAdvancedDataSpaceSearchEnabled: boolean;
   readonly loadDataSpacesState = ActionState.create();
   readonly onDataSpaceChange: (val: DataSpaceInfo) => void;
@@ -76,10 +125,12 @@ export class DataSpaceQueryBuilderState extends QueryBuilderState {
   readonly onRuntimeChange?: ((val: Runtime) => void) | undefined;
   readonly onClassChange?: ((val: Class) => void) | undefined;
   readonly dataSpaceAnalysisResult?: DataSpaceAnalysisResult | undefined;
+  readonly projectInfo?: DataSpaceProjectInfo | undefined;
 
   override TEMPORARY__setupPanelContentRenderer = (): React.ReactNode =>
     renderDataSpaceQueryBuilderSetupPanelContent(this);
 
+  dataSpace: DataSpace;
   executionContext!: DataSpaceExecutionContext;
   dataSpaces: DataSpaceInfo[] = [];
   showRuntimeSelector = false;
@@ -91,27 +142,15 @@ export class DataSpaceQueryBuilderState extends QueryBuilderState {
     depotServerClient: DepotServerClient,
     dataSpace: DataSpace,
     executionContext: DataSpaceExecutionContext,
-    groupId: string,
-    artifactId: string,
-    versionId: string,
-    viewProject: (
-      groupId: string,
-      artifactId: string,
-      versionId: string,
-      entityPath: string | undefined,
-    ) => void,
-    viewSDLCProject: (
-      groupId: string,
-      artifactId: string,
-      entityPath: string | undefined,
-    ) => Promise<void>,
     onDataSpaceChange: (val: DataSpaceInfo) => void,
+    isAdvancedDataSpaceSearchEnabled: boolean,
     dataSpaceAnalysisResult?: DataSpaceAnalysisResult | undefined,
     onExecutionContextChange?:
       | ((val: DataSpaceExecutionContext) => void)
       | undefined,
     onRuntimeChange?: ((val: Runtime) => void) | undefined,
     onClassChange?: ((val: Class) => void) | undefined,
+    projectInfo?: DataSpaceProjectInfo | undefined,
   ) {
     super(applicationStore, graphManagerState);
 
@@ -130,18 +169,12 @@ export class DataSpaceQueryBuilderState extends QueryBuilderState {
     this.depotServerClient = depotServerClient;
     this.dataSpace = dataSpace;
     this.executionContext = executionContext;
-    this.groupId = groupId;
-    this.artifactId = artifactId;
-    this.versionId = versionId;
-    this.viewProject = viewProject;
-    this.viewSDLCProject = viewSDLCProject;
+    this.projectInfo = projectInfo;
     this.onDataSpaceChange = onDataSpaceChange;
     this.onExecutionContextChange = onExecutionContextChange;
     this.onRuntimeChange = onRuntimeChange;
     this.onClassChange = onClassChange;
-    // NOTE: if we reuse this state in the future (e.g. in Studio), we might need
-    // to turn this flag off
-    this.isAdvancedDataSpaceSearchEnabled = true;
+    this.isAdvancedDataSpaceSearchEnabled = isAdvancedDataSpaceSearchEnabled;
     this.dataSpaceAnalysisResult = dataSpaceAnalysisResult;
   }
 
@@ -152,25 +185,27 @@ export class DataSpaceQueryBuilderState extends QueryBuilderState {
   }
 
   showAdvancedSearchPanel(): void {
-    this.advancedSearchState = new DataSpaceAdvancedSearchState(
-      this.applicationStore,
-      this.graphManagerState,
-      this.depotServerClient,
-      {
-        viewProject: this.viewProject,
-        viewSDLCProject: this.viewSDLCProject,
-      },
-      {
-        groupId: this.groupId,
-        artifactId: this.artifactId,
-        versionId: this.versionId,
-        title: this.dataSpace.title,
-        name: this.dataSpace.name,
-        path: this.dataSpace.path,
-        defaultExecutionContext: this.dataSpace.defaultExecutionContext.name,
-      },
-      this.versionId === SNAPSHOT_VERSION_ALIAS,
-    );
+    if (this.projectInfo && this.isAdvancedDataSpaceSearchEnabled) {
+      this.advancedSearchState = new DataSpaceAdvancedSearchState(
+        this.applicationStore,
+        this.graphManagerState,
+        this.depotServerClient,
+        {
+          viewProject: this.projectInfo.viewProject,
+          viewSDLCProject: this.projectInfo.viewSDLCProject,
+        },
+        {
+          groupId: this.projectInfo.groupId,
+          artifactId: this.projectInfo.artifactId,
+          versionId: this.projectInfo.versionId,
+          title: this.dataSpace.title,
+          name: this.dataSpace.name,
+          path: this.dataSpace.path,
+          defaultExecutionContext: this.dataSpace.defaultExecutionContext.name,
+        },
+        this.projectInfo.versionId === SNAPSHOT_VERSION_ALIAS,
+      );
+    }
   }
 
   hideAdvancedSearchPanel(): void {
@@ -186,28 +221,46 @@ export class DataSpaceQueryBuilderState extends QueryBuilderState {
   }
 
   *loadDataSpaces(searchText: string): GeneratorFn<void> {
-    const isValidSearchString =
-      searchText.length >= DEFAULT_TYPEAHEAD_SEARCH_MINIMUM_SEARCH_LENGTH;
-    this.loadDataSpacesState.inProgress();
-    const toGetSnapShot = this.versionId === SNAPSHOT_VERSION_ALIAS;
-    try {
-      this.dataSpaces = (
-        (yield this.depotServerClient.getEntitiesByClassifierPath(
-          DATA_SPACE_ELEMENT_CLASSIFIER_PATH,
-          {
-            search: isValidSearchString ? searchText : undefined,
-            scope: toGetSnapShot ? DepotScope.SNAPSHOT : DepotScope.RELEASES,
-            limit: DEFAULT_TYPEAHEAD_SEARCH_LIMIT,
-          },
-        )) as StoredEntity[]
-      ).map((storedEntity) =>
-        extractDataSpaceInfo(storedEntity, toGetSnapShot),
-      );
-      this.loadDataSpacesState.pass();
-    } catch (error) {
-      assertErrorThrown(error);
-      this.loadDataSpacesState.fail();
-      this.applicationStore.notificationService.notifyError(error);
+    if (this.projectInfo) {
+      const isValidSearchString =
+        searchText.length >= DEFAULT_TYPEAHEAD_SEARCH_MINIMUM_SEARCH_LENGTH;
+      this.loadDataSpacesState.inProgress();
+      const toGetSnapShot =
+        this.projectInfo.versionId === SNAPSHOT_VERSION_ALIAS;
+      try {
+        this.dataSpaces = (
+          (yield this.depotServerClient.getEntitiesByClassifierPath(
+            DATA_SPACE_ELEMENT_CLASSIFIER_PATH,
+            {
+              search: isValidSearchString ? searchText : undefined,
+              scope: toGetSnapShot ? DepotScope.SNAPSHOT : DepotScope.RELEASES,
+              limit: DEFAULT_TYPEAHEAD_SEARCH_LIMIT,
+            },
+          )) as StoredEntity[]
+        ).map((storedEntity) =>
+          extractDataSpaceInfo(storedEntity, toGetSnapShot),
+        );
+        this.loadDataSpacesState.pass();
+      } catch (error) {
+        assertErrorThrown(error);
+        this.loadDataSpacesState.fail();
+        this.applicationStore.notificationService.notifyError(error);
+      }
+    } else {
+      this.dataSpaces = this.graphManagerState.graph.allOwnElements
+        .filter(filterByType(DataSpace))
+        .map(
+          (e) =>
+            ({
+              groupId: undefined,
+              artifactId: undefined,
+              versionId: undefined,
+              path: e.path,
+              name: e.name,
+              title: e.title,
+              defaultExecutionContext: e.defaultExecutionContext.title,
+            }) as DataSpaceInfo,
+        );
     }
   }
 
@@ -233,9 +286,10 @@ export class DataSpaceQueryBuilderState extends QueryBuilderState {
     }
     this.changeRuntime(new RuntimePointer(executionContext.defaultRuntime));
 
-    const compatibleClasses = getMappingCompatibleClasses(
+    const compatibleClasses = resolveUsableDataSpaceClasses(
+      this.dataSpace,
       mapping,
-      this.graphManagerState.usableClasses,
+      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