@finos/legend-extension-dsl-data-space 4.0.3 → 5.0.0

package/src/components/query/DataSpaceQueryEditor.tsx

@@ -0,0 +1,106 @@
+/**
+ * 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 { getQueryParameters } from '@finos/legend-shared';
+import { useApplicationStore } from '@finos/legend-application';
+import {
+  parseGAVCoordinates,
+  useDepotServerClient,
+} from '@finos/legend-server-depot';
+import {
+  LEGEND_QUERY_PATH_PARAM_TOKEN,
+  LEGEND_QUERY_QUERY_PARAM_TOKEN,
+  QueryEditor,
+  QueryEditorStoreContext,
+  useLegendQueryApplicationStore,
+  useLegendQueryBaseStore,
+} from '@finos/legend-query';
+import { useParams } from 'react-router';
+import { DataSpaceQueryEditorStore } from '../../stores/query/DataSpaceQueryEditorStore.js';
+import {
+  type DataSpaceQueryEditorPathParams,
+  type DataSpaceQueryEditorQueryParams,
+  DATA_SPACE_QUERY_EDITOR_PATH_PARAM_TOKEN,
+} from '../../stores/query/DSLDataSpace_LegendQueryRouter.js';
+
+const DataSpaceQueryEditorStoreProvider: 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 depotServerClient = useDepotServerClient();
+  const baseStore = useLegendQueryBaseStore();
+  const store = useLocalObservable(
+    () =>
+      new DataSpaceQueryEditorStore(
+        applicationStore,
+        depotServerClient,
+        baseStore.pluginManager,
+        groupId,
+        artifactId,
+        versionId,
+        dataSpacePath,
+        executionContext,
+        runtimePath,
+        classPath,
+      ),
+  );
+  return (
+    <QueryEditorStoreContext.Provider value={store}>
+      {children}
+    </QueryEditorStoreContext.Provider>
+  );
+};
+
+export const DataSpaceQueryEditor = observer(() => {
+  const applicationStore = useApplicationStore();
+  const params = useParams<DataSpaceQueryEditorPathParams>();
+  const gav = params[LEGEND_QUERY_PATH_PARAM_TOKEN.GAV];
+  const dataSpacePath =
+    params[DATA_SPACE_QUERY_EDITOR_PATH_PARAM_TOKEN.DATA_SPACE_PATH];
+  const executionContext =
+    params[DATA_SPACE_QUERY_EDITOR_PATH_PARAM_TOKEN.EXECUTION_CONTEXT];
+  const runtimePath = params[LEGEND_QUERY_PATH_PARAM_TOKEN.RUNTIME_PATH];
+  const classPath = getQueryParameters<DataSpaceQueryEditorQueryParams>(
+    applicationStore.navigator.getCurrentLocation(),
+    true,
+  )[LEGEND_QUERY_QUERY_PARAM_TOKEN.CLASS_PATH];
+
+  return (
+    <DataSpaceQueryEditorStoreProvider
+      gav={gav}
+      dataSpacePath={dataSpacePath}
+      executionContext={executionContext}
+      runtimePath={runtimePath}
+      classPath={classPath}
+    >
+      <QueryEditor />
+    </DataSpaceQueryEditorStoreProvider>
+  );
+});

package/src/components/query/DataSpaceQuerySetup.tsx

@@ -27,7 +27,7 @@ import {
   CustomSelectorInput,
   SearchIcon,
 } from '@finos/legend-art';
-import { useQuerySetupStore, useLegendQueryStore } from '@finos/legend-query';
+import { useQuerySetupStore } from '@finos/legend-query';
 import { generateGAVCoordinates } from '@finos/legend-server-depot';
 import { debounce } from '@finos/legend-shared';
 import { flowResult } from 'mobx';
@@ -50,7 +50,6 @@ export const DataspaceQuerySetup = observer(
     const { querySetupState } = props;
     const applicationStore = useApplicationStore();
     const setupStore = useQuerySetupStore();
-    const queryStore = useLegendQueryStore();
     const dataSpaceSearchRef = useRef<SelectComponent>(null);
     const [searchText, setSearchText] = useState('');
 
@@ -73,7 +72,6 @@ export const DataspaceQuerySetup = observer(
     const back = (): void => {
       setupStore.setSetupState(undefined);
       querySetupState.setCurrentDataSpace(undefined);
-      queryStore.graphManagerState.resetGraph();
     };
 
     // query
@@ -84,7 +82,6 @@ export const DataspaceQuerySetup = observer(
       : null;
     const onDataSpaceOptionChange = (option: DataSpaceOption | null): void => {
       if (option?.value !== querySetupState.currentDataSpace) {
-        queryStore.graphManagerState.resetGraph();
         querySetupState.setCurrentDataSpace(option?.value);
         querySetupState.setDataSpaceViewerState(undefined);
       }
@@ -133,7 +130,7 @@ export const DataspaceQuerySetup = observer(
     useEffect(() => {
       if (querySetupState.currentDataSpace) {
         flowResult(
-          querySetupState.setUpDataSpace(querySetupState.currentDataSpace),
+          querySetupState.loadDataSpace(querySetupState.currentDataSpace),
         ).catch(applicationStore.alertUnhandledError);
       }
     }, [querySetupState, applicationStore, querySetupState.currentDataSpace]);
@@ -202,40 +199,34 @@ export const DataspaceQuerySetup = observer(
           </div>
           <div className="query-setup__data-space__view">
             <PanelLoadingIndicator
-              isLoading={querySetupState.setUpDataSpaceState.isInProgress}
+              isLoading={querySetupState.loadDataSpaceState.isInProgress}
             />
             {querySetupState.dataSpaceViewerState && (
               <DataSpaceViewer
                 dataSpaceViewerState={querySetupState.dataSpaceViewerState}
               />
             )}
-            {!querySetupState.dataSpaceViewerState &&
-              querySetupState.setUpDataSpaceState.isInProgress && (
-                <BlankPanelContent>
-                  {querySetupState.queryStore.buildGraphState.message ??
-                    querySetupState.queryStore.graphManagerState
-                      .systemBuildState.message ??
-                    querySetupState.queryStore.graphManagerState
-                      .dependenciesBuildState.message ??
-                    querySetupState.queryStore.graphManagerState
-                      .generationsBuildState.message ??
-                    querySetupState.queryStore.graphManagerState.graphBuildState
-                      .message}
-                </BlankPanelContent>
-              )}
-            {!querySetupState.dataSpaceViewerState &&
-              querySetupState.setUpDataSpaceState.hasFailed && (
-                <BlankPanelContent>
-                  <div className="query-setup__data-space__view--failed">
-                    <div className="query-setup__data-space__view--failed__icon">
-                      <TimesCircleIcon />
+            {!querySetupState.dataSpaceViewerState && (
+              <>
+                {querySetupState.loadDataSpaceState.isInProgress && (
+                  <BlankPanelContent>
+                    {querySetupState.loadDataSpaceState.message}
+                  </BlankPanelContent>
+                )}
+                {querySetupState.loadDataSpaceState.hasFailed && (
+                  <BlankPanelContent>
+                    <div className="query-setup__data-space__view--failed">
+                      <div className="query-setup__data-space__view--failed__icon">
+                        <TimesCircleIcon />
+                      </div>
+                      <div className="query-setup__data-space__view--failed__text">
+                        Can&apos;t load data space
+                      </div>
                     </div>
-                    <div className="query-setup__data-space__view--failed__text">
-                      Can&apos;t load data space
-                    </div>
-                  </div>
-                </BlankPanelContent>
-              )}
+                  </BlankPanelContent>
+                )}
+              </>
+            )}
           </div>
         </div>
       </div>

package/src/components/studio/{DSLDataSpace_LegendStudioPlugin.tsx → DSLDataSpace_LegendStudioApplicationPlugin.tsx}

@@ -20,7 +20,7 @@ import {
   type ElementTypeGetter,
   type ElementProjectExplorerDnDTypeGetter,
   type ElementIconGetter,
-  type DSL_LegendStudioPlugin_Extension,
+  type DSL_LegendStudioApplicationPlugin_Extension,
   type NewElementState,
   type ElementEditorStateCreator,
   type EditorStore,
@@ -31,7 +31,7 @@ import {
   type PureGrammarTextSuggestion,
   type PureGrammarParserElementSnippetSuggestionsGetter,
   UnsupportedElementEditorState,
-  LegendStudioPlugin,
+  LegendStudioApplicationPlugin,
 } from '@finos/legend-studio';
 import { SquareIcon } from '@finos/legend-art';
 import {
@@ -50,15 +50,15 @@ import {
   PURE_GRAMMAR_DATA_SPACE_PARSER_NAME,
 } from '../../graphManager/DSLDataSpace_PureGraphManagerPlugin.js';
 import { SIMPLE_DATA_SPACE_SNIPPET } from './DSLDataSpace_CodeSnippets.js';
-import type { LegendApplicationDocumentationEntry } from '@finos/legend-application';
+import type { DocumentationEntry } from '@finos/legend-application';
 
 const DATA_SPACE_ELEMENT_TYPE = 'DATA SPACE';
 const DATA_SPACE_ELEMENT_PROJECT_EXPLORER_DND_TYPE =
   'PROJECT_EXPLORER_DATA_SPACE';
 
-export class DSLDataSpace_LegendStudioPlugin
-  extends LegendStudioPlugin
-  implements DSL_LegendStudioPlugin_Extension
+export class DSLDataSpace_LegendStudioApplicationPlugin
+  extends LegendStudioApplicationPlugin
+  implements DSL_LegendStudioApplicationPlugin_Extension
 {
   constructor() {
     super(packageJson.extensions.studioPlugin, packageJson.version);
@@ -162,7 +162,7 @@ export class DSLDataSpace_LegendStudioPlugin
         editorStore: EditorStore,
         parserKeyword: string,
         elementKeyword: string,
-      ): LegendApplicationDocumentationEntry | undefined => {
+      ): DocumentationEntry | undefined => {
         if (parserKeyword === PURE_GRAMMAR_DATA_SPACE_PARSER_NAME) {
           if (elementKeyword === PURE_GRAMMAR_DATA_SPACE_ELEMENT_TYPE_LABEL) {
             return editorStore.applicationStore.documentationService.getDocEntry(
@@ -180,7 +180,7 @@ export class DSLDataSpace_LegendStudioPlugin
       (
         editorStore: EditorStore,
         parserKeyword: string,
-      ): LegendApplicationDocumentationEntry | undefined => {
+      ): DocumentationEntry | undefined => {
         if (parserKeyword === PURE_GRAMMAR_DATA_SPACE_PARSER_NAME) {
           return editorStore.applicationStore.documentationService.getDocEntry(
             DSL_DATA_SPACE_LEGEND_STUDIO_DOCUMENTATION_KEY.GRAMMAR_PARSER,

package/src/graphManager/DSLDataSpace_PureGraphManagerPlugin.ts

@@ -22,8 +22,10 @@ import {
   type ElementObserver,
   type PackageableElement,
   type PureGrammarElementLabeler,
+  type PureGraphManagerExtensionBuilder,
 } from '@finos/legend-graph';
 import { observe_DataSpace } from './action/changeDetection/DSLDataSpace_ObserverHelper.js';
+import { DSLDataSpace_buildGraphManagerExtension } from './protocol/DSLDataSpace_PureGraphManagerExtensionBuilder.js';
 
 export const PURE_GRAMMAR_DATA_SPACE_PARSER_NAME = 'DataSpace';
 export const PURE_GRAMMAR_DATA_SPACE_ELEMENT_TYPE_LABEL = 'DataSpace';
@@ -33,6 +35,10 @@ export class DSLDataSpace_PureGraphManagerPlugin extends PureGraphManagerPlugin
     super(packageJson.extensions.pureGraphManagerPlugin, packageJson.version);
   }
 
+  override getExtraPureGraphManagerExtensionBuilders(): PureGraphManagerExtensionBuilder[] {
+    return [DSLDataSpace_buildGraphManagerExtension];
+  }
+
   override getExtraPureGrammarParserNames(): string[] {
     return [PURE_GRAMMAR_DATA_SPACE_PARSER_NAME];
   }

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

@@ -0,0 +1,64 @@
+/**
+ * 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 { Diagram } from '@finos/legend-extension-dsl-diagram';
+import type {
+  Mapping,
+  PackageableRuntime,
+  PureModel,
+} from '@finos/legend-graph';
+import { uuid } from '@finos/legend-shared';
+import type { DataSpaceSupportInfo } from '../../../models/metamodels/pure/model/packageableElements/dataSpace/DSLDataSpace_DataSpace.js';
+
+export class DataSpaceExecutionContextAnalysisResult {
+  name!: string;
+  description?: string | undefined;
+  mapping!: Mapping;
+  defaultRuntime!: PackageableRuntime;
+  compatibleRuntimes!: PackageableRuntime[];
+}
+
+export class DataSpaceTaggedValueInfo {
+  readonly _UUID = uuid();
+
+  profile!: string;
+  tag!: string;
+  value!: string;
+}
+
+export class DataSpaceStereotypeInfo {
+  readonly _UUID = uuid();
+
+  profile!: string;
+  value!: string;
+}
+
+export class DataSpaceAnalysisResult {
+  name!: string;
+  package!: string;
+  path!: string;
+  taggedValues: DataSpaceTaggedValueInfo[] = [];
+  stereotypes: DataSpaceStereotypeInfo[] = [];
+  description?: string | undefined;
+  supportInfo?: DataSpaceSupportInfo | undefined;
+
+  graph!: PureModel;
+
+  executionContextsIndex!: Map<string, DataSpaceExecutionContextAnalysisResult>;
+  defaultExecutionContext!: DataSpaceExecutionContextAnalysisResult;
+
+  featuredDiagrams: Diagram[] = [];
+}

package/src/graphManager/protocol/DSLDataSpace_PureGraphManagerExtension.ts

@@ -0,0 +1,42 @@
+/**
+ * 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 AbstractPureGraphManager,
+  AbstractPureGraphManagerExtension,
+} from '@finos/legend-graph';
+import type { Entity } from '@finos/legend-model-storage';
+import { guaranteeNonNullable } from '@finos/legend-shared';
+import type { DataSpaceAnalysisResult } from '../action/analytics/DataSpaceAnalysis.js';
+
+export abstract class DSLDataSpace_PureGraphManagerExtension extends AbstractPureGraphManagerExtension {
+  abstract analyzeDataSpace(
+    dataSpacePath: string,
+    entities: Entity[],
+    dependencyEntitiesIndex: Map<string, Entity[]>,
+  ): Promise<DataSpaceAnalysisResult>;
+}
+
+export const getDSLDataSpaceGraphManagerExtension = (
+  graphManager: AbstractPureGraphManager,
+): DSLDataSpace_PureGraphManagerExtension =>
+  guaranteeNonNullable(
+    graphManager.extensions.find(
+      (extension) =>
+        extension instanceof DSLDataSpace_PureGraphManagerExtension,
+    ),
+    `Can't find DSL Data Space Pure graph manager extension`,
+  ) as DSLDataSpace_PureGraphManagerExtension;

package/src/graphManager/protocol/DSLDataSpace_PureGraphManagerExtensionBuilder.ts

@@ -0,0 +1,27 @@
+/**
+ * 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 {
+  AbstractPureGraphManager,
+  AbstractPureGraphManagerExtension,
+} from '@finos/legend-graph';
+import { V1_DSLDataSpace_PureGraphManagerExtension } from './v1/V1_DSLDataSpace_PureGraphManagerExtension.js';
+
+export const DSLDataSpace_buildGraphManagerExtension = (
+  graphManager: AbstractPureGraphManager,
+): AbstractPureGraphManagerExtension =>
+  // NOTE: until we support more client versions, we always default to return V1
+  new V1_DSLDataSpace_PureGraphManagerExtension(graphManager);

package/src/graphManager/protocol/v1/V1_DSLDataSpace_PureGraphManagerExtension.ts

@@ -0,0 +1,228 @@
+/**
+ * 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 { getDiagram } from '@finos/legend-extension-dsl-diagram';
+import {
+  PureModel,
+  V1_PureGraphManager,
+  PureClientVersion,
+  type AbstractPureGraphManager,
+  CoreModel,
+  SystemModel,
+  V1_Mapping,
+  resolvePackagePathAndElementName,
+  V1_PureModelContextType,
+  V1_PackageableRuntime,
+  V1_EngineRuntime,
+} from '@finos/legend-graph';
+import type { Entity } from '@finos/legend-model-storage';
+import {
+  ActionState,
+  guaranteeNonEmptyString,
+  guaranteeNonNullable,
+  guaranteeType,
+  uniq,
+  type PlainObject,
+} from '@finos/legend-shared';
+import { DataSpaceSupportEmail } from '../../../models/metamodels/pure/model/packageableElements/dataSpace/DSLDataSpace_DataSpace.js';
+import { V1_DataSpaceSupportEmail } from '../../../models/protocols/pure/v1/model/packageableElements/dataSpace/V1_DSLDataSpace_DataSpace.js';
+import {
+  DataSpaceAnalysisResult,
+  DataSpaceExecutionContextAnalysisResult,
+  DataSpaceStereotypeInfo,
+  DataSpaceTaggedValueInfo,
+} from '../../action/analytics/DataSpaceAnalysis.js';
+import { DSLDataSpace_PureGraphManagerExtension } from '../DSLDataSpace_PureGraphManagerExtension.js';
+import { V1_DataSpaceAnalysisResult } from './engine/analytics/V1_DataSpaceAnalysis.js';
+
+const ANALYZE_DATA_SPACE_TRACE = 'analyze data space';
+
+export class V1_DSLDataSpace_PureGraphManagerExtension extends DSLDataSpace_PureGraphManagerExtension {
+  declare graphManager: V1_PureGraphManager;
+
+  constructor(graphManager: AbstractPureGraphManager) {
+    super(graphManager);
+    this.graphManager = guaranteeType(graphManager, V1_PureGraphManager);
+  }
+
+  getSupportedProtocolVersion(): string {
+    return PureClientVersion.V1_0_0;
+  }
+
+  async analyzeDataSpace(
+    dataSpacePath: string,
+    entities: Entity[],
+    dependencyEntitiesIndex: Map<string, Entity[]>,
+  ): Promise<DataSpaceAnalysisResult> {
+    // prepare graph data for analysis
+    // NOTE: we don't do serialization roundtrip here to save time
+    const graphDataForAnalysis = {
+      _type: V1_PureModelContextType.DATA,
+      elements: Array.from(dependencyEntitiesIndex.values())
+        .flat()
+        .concat(entities)
+        .map((entity) => entity.content),
+    };
+
+    const engineServerClient = this.graphManager.engine.getEngineServerClient();
+    const analysisResult = V1_DataSpaceAnalysisResult.serialization.fromJson(
+      await engineServerClient.postWithTracing<
+        PlainObject<V1_DataSpaceAnalysisResult>
+      >(
+        engineServerClient.getTraceData(ANALYZE_DATA_SPACE_TRACE),
+        `${engineServerClient._pure()}/analytics/dataSpace/render`,
+        {
+          clientVersion: V1_PureGraphManager.TARGET_PROTOCOL_VERSION,
+          dataSpace: dataSpacePath,
+          model: graphDataForAnalysis,
+        },
+        {},
+        undefined,
+        undefined,
+        { enableCompression: true },
+      ),
+    );
+
+    const result = new DataSpaceAnalysisResult();
+    result.name = analysisResult.name;
+    result.package = analysisResult.package;
+    result.path = analysisResult.path;
+    result.description = analysisResult.description;
+
+    result.taggedValues = analysisResult.taggedValues.map((taggedValue) => {
+      const info = new DataSpaceTaggedValueInfo();
+      info.profile = taggedValue.profile;
+      info.tag = taggedValue.value;
+      info.value = taggedValue.value;
+      return info;
+    });
+    result.stereotypes = analysisResult.stereotypes.map((stereotype) => {
+      const info = new DataSpaceStereotypeInfo();
+      info.profile = stereotype.profile;
+      info.value = stereotype.value;
+      return info;
+    });
+
+    if (analysisResult.supportInfo) {
+      if (analysisResult.supportInfo instanceof V1_DataSpaceSupportEmail) {
+        const supportEmail = new DataSpaceSupportEmail();
+        supportEmail.address = guaranteeNonEmptyString(
+          analysisResult.supportInfo.address,
+          `Data space support email 'address' field is missing or empty`,
+        );
+        result.supportInfo = supportEmail;
+      }
+      // NOTE: we will relax the check and not throw here for unknown support info type
+    }
+
+    // create an empty graph
+    const extensionElementClasses = this.graphManager.pluginManager
+      .getPureGraphPlugins()
+      .flatMap((plugin) => plugin.getExtraPureGraphExtensionClasses?.() ?? []);
+    const systemModel = new SystemModel(extensionElementClasses);
+    const coreModel = new CoreModel(extensionElementClasses);
+    await this.graphManager.buildSystem(
+      coreModel,
+      systemModel,
+      ActionState.create(),
+      {},
+    );
+    systemModel.initializeAutoImports();
+    const graph = new PureModel(
+      coreModel,
+      systemModel,
+      this.graphManager.pluginManager.getPureGraphPlugins(),
+    );
+
+    // 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(
+      analysisResult.executionContexts.map((context) => context.mapping),
+    ).map((path) => {
+      const mapping = new V1_Mapping();
+      const [packagePath, name] = resolvePackagePathAndElementName(path);
+      mapping.package = packagePath;
+      mapping.name = name;
+      return mapping;
+    });
+    const runtimeModels = uniq(
+      analysisResult.executionContexts
+        .map((context) => context.defaultRuntime)
+        .concat(
+          analysisResult.executionContexts.flatMap(
+            (val) => val.compatibleRuntimes,
+          ),
+        ),
+    ).map((path) => {
+      const runtime = new V1_PackageableRuntime();
+      const [packagePath, name] = resolvePackagePathAndElementName(path);
+      runtime.package = packagePath;
+      runtime.name = name;
+      runtime.runtimeValue = new V1_EngineRuntime();
+      return runtime;
+    });
+
+    // prepare the model context data
+    // scan for models coming from system so we don't duplicate them when building the graph
+    const graphEntities = analysisResult.model.elements
+      .concat(mappingModels)
+      .concat(runtimeModels)
+      // 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))
+      .map((el) => this.graphManager.elementProtocolToEntity(el));
+
+    await this.graphManager.buildGraph(
+      graph,
+      graphEntities,
+      ActionState.create(),
+    );
+
+    // build execution context info
+    result.executionContextsIndex = new Map<
+      string,
+      DataSpaceExecutionContextAnalysisResult
+    >();
+    analysisResult.executionContexts.forEach((context) => {
+      const contextAnalysisResult =
+        new DataSpaceExecutionContextAnalysisResult();
+      contextAnalysisResult.name = context.name;
+      contextAnalysisResult.description = context.description;
+      contextAnalysisResult.mapping = graph.getMapping(context.mapping);
+      contextAnalysisResult.defaultRuntime = graph.getRuntime(
+        context.defaultRuntime,
+      );
+      contextAnalysisResult.compatibleRuntimes = context.compatibleRuntimes.map(
+        (runtime) => graph.getRuntime(runtime),
+      );
+      result.executionContextsIndex.set(
+        contextAnalysisResult.name,
+        contextAnalysisResult,
+      );
+    });
+    result.defaultExecutionContext = guaranteeNonNullable(
+      result.executionContextsIndex.get(analysisResult.defaultExecutionContext),
+    );
+
+    // find featured diagrams
+    result.featuredDiagrams = analysisResult.featuredDiagrams.map((path) =>
+      getDiagram(path, graph),
+    );
+
+    return result;
+  }
+}