@finos/legend-extension-dsl-data-space 9.2.0 → 9.2.2

package/src/components/query/DataSpaceQueryCreator.tsx

@@ -80,7 +80,7 @@ export const DataSpaceQueryCreator = observer(() => {
   const runtimePath =
     parameters[DATA_SPACE_QUERY_CREATOR_ROUTE_PATTERN_TOKEN.RUNTIME_PATH];
   const classPath =
-    applicationStore.navigationService.navigator.getAddressParameterValue(
+    applicationStore.navigationService.navigator.getCurrentLocationParameterValue(
       DATA_SPACE_QUERY_CREATOR_QUERY_PARAM_TOKEN.CLASS_PATH,
     );
 

package/src/graphManager/action/analytics/DataSpaceAnalysis.ts

@@ -52,15 +52,18 @@ export class DataSpaceDocumentationEntry {
   readonly elementPath: string;
   readonly subElementText?: string | undefined;
   readonly doc: string;
+  readonly milestoning?: string | undefined;
 
   constructor(
     elementPath: string,
     subElementText: string | undefined,
     documentation: string,
+    milestoning: string | undefined,
   ) {
     this.elementPath = elementPath;
     this.subElementText = subElementText;
     this.doc = documentation;
+    this.milestoning = milestoning;
   }
 }
 

package/src/graphManager/protocol/pure/v1/V1_DSL_DataSpace_PureGraphManagerExtension.ts

@@ -316,20 +316,22 @@ export class V1_DSL_DataSpace_PureGraphManagerExtension extends DSL_DataSpace_Pu
     // elements documentation
     result.elementDocs = analysisResult.elementDocs.flatMap((docEntry) => {
       const entries: DataSpaceDocumentationEntry[] = [];
-      entries.push(
-        new DataSpaceDocumentationEntry(
-          docEntry.path,
-          undefined,
-          docEntry.docs.join('\n'),
-        ),
-      );
       if (docEntry instanceof V1_DataSpaceClassDocumentationEntry) {
+        entries.push(
+          new DataSpaceDocumentationEntry(
+            docEntry.path,
+            undefined,
+            docEntry.docs.join('\n'),
+            docEntry.milestoning,
+          ),
+        );
         docEntry.properties.forEach((property) => {
           entries.push(
             new DataSpaceDocumentationEntry(
               docEntry.path,
               property.name,
               property.docs.join('\n'),
+              property.milestoning,
             ),
           );
         });
@@ -337,24 +339,42 @@ export class V1_DSL_DataSpace_PureGraphManagerExtension extends DSL_DataSpace_Pu
       } else if (
         docEntry instanceof V1_DataSpaceEnumerationDocumentationEntry
       ) {
+        entries.push(
+          new DataSpaceDocumentationEntry(
+            docEntry.path,
+            undefined,
+            docEntry.docs.join('\n'),
+            undefined,
+          ),
+        );
         docEntry.enumValues.forEach((enumValue) => {
           entries.push(
             new DataSpaceDocumentationEntry(
               docEntry.path,
               enumValue.name,
               enumValue.docs.join('\n'),
+              undefined,
             ),
           );
         });
       } else if (
         docEntry instanceof V1_DataSpaceAssociationDocumentationEntry
       ) {
+        entries.push(
+          new DataSpaceDocumentationEntry(
+            docEntry.path,
+            undefined,
+            docEntry.docs.join('\n'),
+            undefined,
+          ),
+        );
         docEntry.properties.forEach((property) => {
           entries.push(
             new DataSpaceDocumentationEntry(
               docEntry.path,
               property.name,
               property.docs.join('\n'),
+              property.milestoning,
             ),
           );
         });

package/src/graphManager/protocol/pure/v1/engine/analytics/V1_DataSpaceAnalysis.ts

@@ -74,11 +74,11 @@ class V1_DataSpaceExecutionContextAnalysisResult {
 
   static readonly serialization = new SerializationFactory(
     createModelSchema(V1_DataSpaceExecutionContextAnalysisResult, {
-      name: primitive(),
+      compatibleRuntimes: list(primitive()),
+      defaultRuntime: primitive(),
       description: optional(primitive()),
       mapping: primitive(),
-      defaultRuntime: primitive(),
-      compatibleRuntimes: list(primitive()),
+      name: primitive(),
       title: optional(primitive()),
     }),
   );
@@ -90,8 +90,20 @@ export class V1_DataSpaceBasicDocumentationEntry {
 
   static readonly serialization = new SerializationFactory(
     createModelSchema(V1_DataSpaceBasicDocumentationEntry, {
+      docs: list(primitive()),
       name: primitive(),
+    }),
+  );
+}
+
+export class V1_DataSpacePropertyDocumentationEntry extends V1_DataSpaceBasicDocumentationEntry {
+  milestoning?: string;
+
+  static override readonly serialization = new SerializationFactory(
+    createModelSchema(V1_DataSpacePropertyDocumentationEntry, {
       docs: list(primitive()),
+      milestoning: optional(primitive()),
+      name: primitive(),
     }),
   );
 }
@@ -101,24 +113,24 @@ export class V1_DataSpaceModelDocumentationEntry extends V1_DataSpaceBasicDocume
 
   static override readonly serialization = new SerializationFactory(
     createModelSchema(V1_DataSpaceModelDocumentationEntry, {
-      name: primitive(),
       docs: list(primitive()),
+      name: primitive(),
       path: primitive(),
     }),
   );
 }
 
 export class V1_DataSpaceClassDocumentationEntry extends V1_DataSpaceModelDocumentationEntry {
-  inheritedProperties: V1_DataSpaceBasicDocumentationEntry[] = [];
-  properties: V1_DataSpaceBasicDocumentationEntry[] = [];
+  properties: V1_DataSpacePropertyDocumentationEntry[] = [];
+  milestoning?: string;
 
   static override readonly serialization = new SerializationFactory(
     createModelSchema(V1_DataSpaceClassDocumentationEntry, {
-      name: primitive(),
       docs: list(primitive()),
+      milestoning: optional(primitive()),
+      name: primitive(),
       path: primitive(),
-      inheritedProperties: list(object(V1_DataSpaceBasicDocumentationEntry)),
-      properties: list(object(V1_DataSpaceBasicDocumentationEntry)),
+      properties: list(object(V1_DataSpacePropertyDocumentationEntry)),
     }),
   );
 }
@@ -128,23 +140,23 @@ export class V1_DataSpaceEnumerationDocumentationEntry extends V1_DataSpaceModel
 
   static override readonly serialization = new SerializationFactory(
     createModelSchema(V1_DataSpaceEnumerationDocumentationEntry, {
-      name: primitive(),
-      docs: list(primitive()),
       enumValues: list(object(V1_DataSpaceBasicDocumentationEntry)),
+      docs: list(primitive()),
+      name: primitive(),
       path: primitive(),
     }),
   );
 }
 
 export class V1_DataSpaceAssociationDocumentationEntry extends V1_DataSpaceModelDocumentationEntry {
-  properties: V1_DataSpaceBasicDocumentationEntry[] = [];
+  properties: V1_DataSpacePropertyDocumentationEntry[] = [];
 
   static override readonly serialization = new SerializationFactory(
     createModelSchema(V1_DataSpaceAssociationDocumentationEntry, {
-      name: primitive(),
       docs: list(primitive()),
+      name: primitive(),
       path: primitive(),
-      properties: list(object(V1_DataSpaceBasicDocumentationEntry)),
+      properties: list(object(V1_DataSpacePropertyDocumentationEntry)),
     }),
   );
 }

package/src/stores/DataSpaceViewerDataAccessState.ts

@@ -0,0 +1,142 @@
+/**
+ * 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 {
+  type GeneratorFn,
+  ActionState,
+  assertErrorThrown,
+  uuid,
+} from '@finos/legend-shared';
+import { action, flow, makeObservable, observable } from 'mobx';
+import type { DataSpaceViewerState } from './DataSpaceViewerState.js';
+import type {
+  DatasetSpecification,
+  DatasetEntitlementReport,
+} from '@finos/legend-graph';
+
+export class DataSpaceDatasetInfo {
+  readonly uuid = uuid();
+  readonly specification!: DatasetSpecification;
+
+  entitlementReport?: DatasetEntitlementReport | undefined;
+
+  constructor(specification: DatasetSpecification) {
+    makeObservable(this, {
+      entitlementReport: observable,
+      setEntitlementReport: action,
+    });
+
+    this.specification = specification;
+  }
+
+  setEntitlementReport(val: DatasetEntitlementReport | undefined): void {
+    this.entitlementReport = val;
+  }
+}
+
+export class DataSpaceViewerDataAccessState {
+  readonly dataSpaceViewerState: DataSpaceViewerState;
+
+  readonly fetchDatasetSpecificationsState = ActionState.create();
+  readonly fetchDatasetEntitlementReportsState = ActionState.create();
+
+  datasets: DataSpaceDatasetInfo[] = [];
+
+  constructor(dataSpaceViewerState: DataSpaceViewerState) {
+    makeObservable(this, {
+      datasets: observable,
+      fetchDatasetSpecifications: flow,
+      fetchDatasetEntitlementReports: flow,
+    });
+
+    this.dataSpaceViewerState = dataSpaceViewerState;
+  }
+
+  *fetchDatasetSpecifications(): GeneratorFn<void> {
+    this.fetchDatasetSpecificationsState.inProgress();
+
+    try {
+      const datasets =
+        (yield this.dataSpaceViewerState.graphManagerState.graphManager.surveyDatasets(
+          this.dataSpaceViewerState.currentExecutionContext.mapping,
+          this.dataSpaceViewerState.currentExecutionContext.defaultRuntime,
+          undefined,
+          this.dataSpaceViewerState.retriveGraphData(),
+        )) as DatasetSpecification[];
+      this.datasets = datasets.map((dataset) => {
+        const existingDataset = this.datasets.find(
+          (ds) => ds.specification.hashCode === dataset.hashCode,
+        );
+        if (existingDataset) {
+          return existingDataset;
+        }
+        return new DataSpaceDatasetInfo(dataset);
+      });
+    } catch (error) {
+      assertErrorThrown(error);
+      this.dataSpaceViewerState.applicationStore.notificationService.notifyError(
+        error,
+      );
+    } finally {
+      this.fetchDatasetSpecificationsState.complete();
+    }
+  }
+
+  *fetchDatasetEntitlementReports(): GeneratorFn<void> {
+    this.fetchDatasetEntitlementReportsState.inProgress();
+
+    try {
+      const reports =
+        (yield this.dataSpaceViewerState.graphManagerState.graphManager.checkEntitlements(
+          this.dataSpaceViewerState.currentExecutionContext.mapping,
+          this.dataSpaceViewerState.currentExecutionContext.defaultRuntime,
+          undefined,
+          this.dataSpaceViewerState.retriveGraphData(),
+        )) as DatasetEntitlementReport[];
+      this.datasets.forEach((dataset) => {
+        const matchingReport = reports.find(
+          (report) =>
+            report.dataset.hashCode === dataset.specification.hashCode,
+        );
+        if (matchingReport) {
+          dataset.setEntitlementReport(matchingReport);
+          return;
+        }
+        dataset.setEntitlementReport(undefined);
+      });
+      const newDatasets: DataSpaceDatasetInfo[] = [];
+      reports.forEach((report) => {
+        const matchingDataset = this.datasets.find(
+          (dataset) =>
+            dataset.specification.hashCode === report.dataset.hashCode,
+        );
+        if (!matchingDataset) {
+          const newDataset = new DataSpaceDatasetInfo(report.dataset);
+          newDataset.setEntitlementReport(report);
+          newDatasets.push(newDataset);
+        }
+      });
+      this.datasets = this.datasets.concat(newDatasets);
+    } catch (error) {
+      assertErrorThrown(error);
+      this.dataSpaceViewerState.applicationStore.notificationService.notifyError(
+        error,
+      );
+    } finally {
+      this.fetchDatasetEntitlementReportsState.complete();
+    }
+  }
+}

package/src/stores/DataSpaceViewerState.ts

@@ -14,7 +14,10 @@
  * limitations under the License.
  */
 
-import type { GenericLegendApplicationStore } from '@finos/legend-application';
+import type {
+  GenericLegendApplicationStore,
+  NavigationZone,
+} from '@finos/legend-application';
 import {
   type ClassView,
   type DiagramRenderer,
@@ -22,6 +25,7 @@ import {
 } from '@finos/legend-extension-dsl-diagram';
 import type {
   BasicGraphManagerState,
+  GraphData,
   PackageableRuntime,
 } from '@finos/legend-graph';
 import {
@@ -38,32 +42,54 @@ import {
   PURE_DATA_SPACE_INFO_PROFILE_PATH,
   PURE_DATA_SPACE_INFO_PROFILE_VERIFIED_STEREOTYPE,
 } from '../graphManager/DSL_DataSpace_PureGraphManagerPlugin.js';
+import { DataSpaceViewerDataAccessState } from './DataSpaceViewerDataAccessState.js';
 
 export enum DATA_SPACE_VIEWER_ACTIVITY_MODE {
-  DESCRIPTION = 'DESCRIPTION',
-  DIAGRAM_VIEWER = 'DIAGRAM_VIEWER',
-  MODELS_DOCUMENTATION = 'MODELS_DOCUMENTATION',
-  QUICK_START = 'QUICK_START',
-  EXECUTION_CONTEXT = 'EXECUTION_CONTEXT',
-  DATA_ACCESS = 'DATA_ACCESS',
-
-  DATA_STORES = 'DATA_STORES', // TODO: with test-data, also let user call TDS query on top of these
-  DATA_AVAILABILITY = 'DATA_AVAILABILITY',
-  DATA_READINESS = 'DATA_READINESS',
-  DATA_COST = 'DATA_COST',
-  DATA_GOVERNANCE = 'DATA_GOVERNANCE',
-  INFO = 'INFO', // TODO: test coverage? (or maybe this should be done in elements/diagrams/data-quality section)
-  SUPPORT = 'SUPPORT',
+  DESCRIPTION = 'description',
+  DIAGRAM_VIEWER = 'diagram_viewer',
+  MODELS_DOCUMENTATION = 'models_documentation',
+  QUICK_START = 'quick_start',
+  EXECUTION_CONTEXT = 'execution_context',
+  DATA_ACCESS = 'data_access',
+
+  DATA_STORES = 'data_stores', // TODO: with test-data, also let user call TDS query on top of these
+  DATA_AVAILABILITY = 'data_availability',
+  DATA_READINESS = 'data_readiness',
+  DATA_COST = 'data_cost',
+  DATA_GOVERNANCE = 'data_governance',
+  INFO = 'info', // TODO: test coverage? (or maybe this should be done in elements/diagrams/data-quality section)
+  SUPPORT = 'support',
+}
+
+class DataSpaceLayoutState {
+  readonly dataSpaceViewerState: DataSpaceViewerState;
+
+  isExpandedModeEnabled = false;
+
+  constructor(dataSpaceViewerState: DataSpaceViewerState) {
+    makeObservable(this, {
+      isExpandedModeEnabled: observable,
+      enableExpandedMode: action,
+    });
+
+    this.dataSpaceViewerState = dataSpaceViewerState;
+  }
+
+  enableExpandedMode(val: boolean): void {
+    this.isExpandedModeEnabled = val;
+  }
 }
 
 export class DataSpaceViewerState {
   readonly applicationStore: GenericLegendApplicationStore;
   readonly graphManagerState: BasicGraphManagerState;
+  readonly layoutState: DataSpaceLayoutState;
 
+  readonly dataSpaceAnalysisResult: DataSpaceAnalysisResult;
   readonly groupId: string;
   readonly artifactId: string;
   readonly versionId: string;
-  readonly dataSpaceAnalysisResult: DataSpaceAnalysisResult;
+  readonly retriveGraphData: () => GraphData;
   readonly viewProject: (
     groupId: string,
     artifactId: string,
@@ -76,6 +102,11 @@ export class DataSpaceViewerState {
     entityPath: string | undefined,
   ) => Promise<void>;
   readonly onDiagramClassDoubleClick: (classView: ClassView) => void;
+  readonly onZoneChange?:
+    | ((zone: NavigationZone | undefined) => void)
+    | undefined;
+
+  readonly dataAccessState: DataSpaceViewerDataAccessState;
 
   _renderer?: DiagramRenderer | undefined;
   currentDiagram?: DataSpaceDiagramAnalysisResult | undefined;
@@ -83,8 +114,6 @@ export class DataSpaceViewerState {
   currentExecutionContext: DataSpaceExecutionContextAnalysisResult;
   currentRuntime: PackageableRuntime;
 
-  isExpandedModeEnabled = false;
-
   constructor(
     applicationStore: GenericLegendApplicationStore,
     graphManagerState: BasicGraphManagerState,
@@ -93,6 +122,7 @@ export class DataSpaceViewerState {
     versionId: string,
     dataSpaceAnalysisResult: DataSpaceAnalysisResult,
     actions: {
+      retriveGraphData: () => GraphData;
       viewProject: (
         groupId: string,
         artifactId: string,
@@ -105,6 +135,7 @@ export class DataSpaceViewerState {
         entityPath: string | undefined,
       ) => Promise<void>;
       onDiagramClassDoubleClick: (classView: ClassView) => void;
+      onZoneChange?: ((zone: NavigationZone | undefined) => void) | undefined;
     },
   ) {
     makeObservable(this, {
@@ -113,19 +144,19 @@ export class DataSpaceViewerState {
       currentActivity: observable,
       currentExecutionContext: observable,
       currentRuntime: observable,
-      isExpandedModeEnabled: observable,
       isVerified: computed,
-      renderer: computed,
-      setRenderer: action,
+      diagramRenderer: computed,
+      setDiagramRenderer: action,
       setCurrentDiagram: action,
       setCurrentActivity: action,
       setCurrentExecutionContext: action,
       setCurrentRuntime: action,
-      enableExpandedMode: action,
     });
 
     this.applicationStore = applicationStore;
     this.graphManagerState = graphManagerState;
+    this.layoutState = new DataSpaceLayoutState(this);
+
     this.dataSpaceAnalysisResult = dataSpaceAnalysisResult;
     this.groupId = groupId;
     this.artifactId = artifactId;
@@ -136,12 +167,16 @@ export class DataSpaceViewerState {
     this.currentDiagram = getNullableFirstElement(
       this.dataSpaceAnalysisResult.diagrams,
     );
+    this.retriveGraphData = actions.retriveGraphData;
     this.viewProject = actions.viewProject;
     this.viewSDLCProject = actions.viewSDLCProject;
     this.onDiagramClassDoubleClick = actions.onDiagramClassDoubleClick;
+    this.onZoneChange = actions.onZoneChange;
+
+    this.dataAccessState = new DataSpaceViewerDataAccessState(this);
   }
 
-  get renderer(): DiagramRenderer {
+  get diagramRenderer(): DiagramRenderer {
     return guaranteeNonNullable(
       this._renderer,
       `Diagram renderer must be initialized (this is likely caused by calling this method at the wrong place)`,
@@ -160,12 +195,12 @@ export class DataSpaceViewerState {
     if (!this.isDiagramRendererInitialized) {
       return '';
     }
-    if (this.renderer.middleClick || this.renderer.rightClick) {
+    if (this.diagramRenderer.middleClick || this.diagramRenderer.rightClick) {
       return 'diagram-editor__cursor--grabbing';
     }
-    switch (this.renderer.interactionMode) {
+    switch (this.diagramRenderer.interactionMode) {
       case DIAGRAM_INTERACTION_MODE.LAYOUT: {
-        if (this.renderer.mouseOverClassView) {
+        if (this.diagramRenderer.mouseOverClassView) {
           return 'diagram-editor__cursor--pointer';
         }
         return '';
@@ -185,7 +220,7 @@ export class DataSpaceViewerState {
     );
   }
 
-  setRenderer(val: DiagramRenderer): void {
+  setDiagramRenderer(val: DiagramRenderer): void {
     this._renderer = val;
   }
 
@@ -208,14 +243,71 @@ export class DataSpaceViewerState {
     this.currentRuntime = val;
   }
 
-  setupRenderer(): void {
-    this.renderer.setIsReadOnly(true);
-    this.renderer.setEnableLayoutAutoAdjustment(true);
-    this.renderer.onClassViewDoubleClick = (classView: ClassView): void =>
-      this.onDiagramClassDoubleClick(classView);
+  setupDiagramRenderer(): void {
+    this.diagramRenderer.setIsReadOnly(true);
+    this.diagramRenderer.setEnableLayoutAutoAdjustment(true);
+    this.diagramRenderer.onClassViewDoubleClick = (
+      classView: ClassView,
+    ): void => this.onDiagramClassDoubleClick(classView);
   }
 
-  enableExpandedMode(val: boolean): void {
-    this.isExpandedModeEnabled = val;
+  changeZone(zone: NavigationZone): void {
+    switch (zone) {
+      case DATA_SPACE_VIEWER_ACTIVITY_MODE.DESCRIPTION:
+      case DATA_SPACE_VIEWER_ACTIVITY_MODE.DIAGRAM_VIEWER:
+      case DATA_SPACE_VIEWER_ACTIVITY_MODE.MODELS_DOCUMENTATION:
+      case DATA_SPACE_VIEWER_ACTIVITY_MODE.QUICK_START: {
+        this.setCurrentActivity(DATA_SPACE_VIEWER_ACTIVITY_MODE.DESCRIPTION);
+        break;
+      }
+      case DATA_SPACE_VIEWER_ACTIVITY_MODE.EXECUTION_CONTEXT: {
+        this.setCurrentActivity(
+          DATA_SPACE_VIEWER_ACTIVITY_MODE.EXECUTION_CONTEXT,
+        );
+        break;
+      }
+      case DATA_SPACE_VIEWER_ACTIVITY_MODE.DATA_ACCESS: {
+        this.setCurrentActivity(DATA_SPACE_VIEWER_ACTIVITY_MODE.DATA_ACCESS);
+        break;
+      }
+      case DATA_SPACE_VIEWER_ACTIVITY_MODE.DATA_STORES: {
+        this.setCurrentActivity(DATA_SPACE_VIEWER_ACTIVITY_MODE.DATA_STORES);
+        break;
+      }
+      case DATA_SPACE_VIEWER_ACTIVITY_MODE.DATA_AVAILABILITY: {
+        this.setCurrentActivity(
+          DATA_SPACE_VIEWER_ACTIVITY_MODE.DATA_AVAILABILITY,
+        );
+        break;
+      }
+      case DATA_SPACE_VIEWER_ACTIVITY_MODE.DATA_READINESS: {
+        this.setCurrentActivity(DATA_SPACE_VIEWER_ACTIVITY_MODE.DATA_READINESS);
+        break;
+      }
+      case DATA_SPACE_VIEWER_ACTIVITY_MODE.DATA_COST: {
+        this.setCurrentActivity(DATA_SPACE_VIEWER_ACTIVITY_MODE.DATA_COST);
+        break;
+      }
+      case DATA_SPACE_VIEWER_ACTIVITY_MODE.DATA_GOVERNANCE: {
+        this.setCurrentActivity(
+          DATA_SPACE_VIEWER_ACTIVITY_MODE.DATA_GOVERNANCE,
+        );
+        break;
+      }
+      case DATA_SPACE_VIEWER_ACTIVITY_MODE.INFO: {
+        this.setCurrentActivity(DATA_SPACE_VIEWER_ACTIVITY_MODE.INFO);
+        break;
+      }
+      case DATA_SPACE_VIEWER_ACTIVITY_MODE.SUPPORT: {
+        this.setCurrentActivity(DATA_SPACE_VIEWER_ACTIVITY_MODE.SUPPORT);
+        break;
+      }
+      default: {
+        // unknown
+        this.setCurrentActivity(DATA_SPACE_VIEWER_ACTIVITY_MODE.DESCRIPTION);
+        this.onZoneChange?.(undefined);
+        break;
+      }
+    }
   }
 }

package/src/stores/query/DataSpaceAdvancedSearchState.ts

@@ -15,7 +15,12 @@
  */
 
 import type { ClassView } from '@finos/legend-extension-dsl-diagram';
-import type { Class, GraphManagerState } from '@finos/legend-graph';
+import {
+  GraphDataWithOrigin,
+  type Class,
+  type GraphManagerState,
+  LegendSDLC,
+} from '@finos/legend-graph';
 import {
   type StoredEntity,
   type DepotServerClient,
@@ -192,6 +197,14 @@ export class DataSpaceAdvancedSearchState {
         dataSpace.versionId,
         analysisResult,
         {
+          retriveGraphData: () =>
+            new GraphDataWithOrigin(
+              new LegendSDLC(
+                dataSpace.groupId,
+                dataSpace.artifactId,
+                dataSpace.versionId,
+              ),
+            ),
           viewProject: this.viewProject,
           viewSDLCProject: this.viewSDLCProject,
           onDiagramClassDoubleClick: (classView: ClassView): void => {

package/src/stores/studio/DataSpacePreviewState.ts

@@ -31,6 +31,7 @@ import type { DataSpace } from '../../graph/metamodel/pure/model/packageableElem
 import type { DataSpaceAnalysisResult } from '../../graphManager/action/analytics/DataSpaceAnalysis.js';
 import { DSL_DataSpace_getGraphManagerExtension } from '../../graphManager/protocol/pure/DSL_DataSpace_PureGraphManagerExtension.js';
 import { DataSpaceViewerState } from '../DataSpaceViewerState.js';
+import { LiveGraphData } from '@finos/legend-graph';
 
 export class DataSpacePreviewState extends EditorExtensionState {
   readonly editorStore: EditorStore;
@@ -116,6 +117,8 @@ export class DataSpacePreviewState extends EditorExtensionState {
         versionId,
         analysisResult,
         {
+          retriveGraphData: () =>
+            new LiveGraphData(this.editorStore.graphManagerState.graph),
           viewProject: () => {
             this.editorStore.applicationStore.notificationService.notifyWarning(
               'This feature is not supported in preview mode',

package/tsconfig.json

@@ -57,6 +57,7 @@
     "./src/graphManager/protocol/pure/v1/transformation/pureGraph/V1_DSL_DataSpace_GraphBuilderHelper.ts",
     "./src/graphManager/protocol/pure/v1/transformation/pureProtocol/V1_DSL_DataSpace_ProtocolHelper.ts",
     "./src/stores/DSL_DataSpace_LegendApplicationPlugin_Extension.ts",
+    "./src/stores/DataSpaceViewerDataAccessState.ts",
     "./src/stores/DataSpaceViewerState.ts",
     "./src/stores/query/DataSpaceAdvancedSearchState.ts",
     "./src/stores/query/DataSpaceInfo.ts",