@finos/legend-extension-dsl-data-space 4.0.4 → 6.0.0

package/src/graph/DSLDataSpace_PureGraphPlugin.ts

@@ -15,7 +15,7 @@
  */
 
 import packageJson from '../../package.json';
-import { DataSpace } from '../models/metamodels/pure/model/packageableElements/dataSpace/DSLDataSpace_DataSpace.js';
+import { DataSpace } from '../graph/metamodel/pure/model/packageableElements/dataSpace/DSLDataSpace_DataSpace.js';
 import type { Clazz } from '@finos/legend-shared';
 import { type PackageableElement, PureGraphPlugin } from '@finos/legend-graph';
 

package/src/{models/metamodels → graph/metamodel}/pure/model/packageableElements/dataSpace/DSLDataSpace_DataSpace.ts

@@ -22,7 +22,7 @@ import {
   type PackageableRuntime,
   type PackageableElementVisitor,
 } from '@finos/legend-graph';
-import { DATA_SPACE_HASH_STRUCTURE } from '../../../../../DSLDataSpace_ModelUtils.js';
+import { DATA_SPACE_HASH_STRUCTURE } from '../../../../../DSLDataSpace_HashUtils.js';
 import type { Diagram } from '@finos/legend-extension-dsl-diagram';
 
 export abstract class DataSpaceSupportInfo implements Hashable {

package/src/graphManager/DSLDataSpace_GraphManagerHelper.ts

@@ -16,7 +16,7 @@
 
 import type { BasicModel, PureModel } from '@finos/legend-graph';
 import { guaranteeNonNullable } from '@finos/legend-shared';
-import { DataSpace } from '../models/metamodels/pure/model/packageableElements/dataSpace/DSLDataSpace_DataSpace.js';
+import { DataSpace } from '../graph/metamodel/pure/model/packageableElements/dataSpace/DSLDataSpace_DataSpace.js';
 
 export const getDataSpace = (path: string, graph: PureModel): DataSpace =>
   graph.getExtensionElement(path, DataSpace, `Can't find data space '${path}'`);

package/src/graphManager/DSLDataSpace_PureGraphManagerPlugin.ts

@@ -15,15 +15,17 @@
  */
 
 import packageJson from '../../package.json';
-import { DataSpace } from '../models/metamodels/pure/model/packageableElements/dataSpace/DSLDataSpace_DataSpace.js';
+import { DataSpace } from '../graph/metamodel/pure/model/packageableElements/dataSpace/DSLDataSpace_DataSpace.js';
 import {
   PureGraphManagerPlugin,
   type ObserverContext,
   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/pure/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 '../../../graph/metamodel/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/action/changeDetection/DSLDataSpace_ObserverHelper.ts

@@ -21,7 +21,7 @@ import {
   skipObserved,
 } from '@finos/legend-graph';
 import { makeObservable, override } from 'mobx';
-import type { DataSpace } from '../../../models/metamodels/pure/model/packageableElements/dataSpace/DSLDataSpace_DataSpace.js';
+import type { DataSpace } from '../../../graph/metamodel/pure/model/packageableElements/dataSpace/DSLDataSpace_DataSpace.js';
 
 export const observe_DataSpace = skipObserved(
   (metamodel: DataSpace): DataSpace => {
@@ -31,6 +31,7 @@ export const observe_DataSpace = skipObserved(
       _elementHashCode: override,
     });
 
+    // TODO
     // metamodel.executionContexts.forEach(observe_DataSpaceExecutionContext);
     // observe_DataSpaceExecutionContext(metamodel.defaultExecutionContext);
     // if (metamodel.supportInfo) {

package/src/graphManager/protocol/pure/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-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/pure/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/{models/protocols → graphManager/protocol}/pure/DSLDataSpace_PureProtocolProcessorPlugin.ts

@@ -39,7 +39,7 @@ import {
   DataSpace,
   DataSpaceExecutionContext,
   DataSpaceSupportEmail,
-} from '../../metamodels/pure/model/packageableElements/dataSpace/DSLDataSpace_DataSpace.js';
+} from '../../../graph/metamodel/pure/model/packageableElements/dataSpace/DSLDataSpace_DataSpace.js';
 import {
   type PackageableElement,
   type V1_ElementProtocolClassifierPathGetter,

package/src/graphManager/protocol/pure/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-storage';
+import {
+  ActionState,
+  guaranteeNonEmptyString,
+  guaranteeNonNullable,
+  guaranteeType,
+  uniq,
+  type PlainObject,
+} from '@finos/legend-shared';
+import { DataSpaceSupportEmail } from '../../../../graph/metamodel/pure/model/packageableElements/dataSpace/DSLDataSpace_DataSpace.js';
+import { V1_DataSpaceSupportEmail } from '../../../../graphManager/protocol/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;
+  }
+}

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

@@ -0,0 +1,117 @@
+/**
+ * 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 { V1_PureModelContextData } from '@finos/legend-graph';
+import { SerializationFactory, optionalCustom } from '@finos/legend-shared';
+import {
+  createModelSchema,
+  list,
+  object,
+  optional,
+  primitive,
+  SKIP,
+} from 'serializr';
+import type { V1_DataSpaceSupportInfo } from '../../../../../../graphManager/protocol/pure/v1/model/packageableElements/dataSpace/V1_DSLDataSpace_DataSpace.js';
+import { V1_deserializeSupportInfo } from '../../../../../../graphManager/protocol/pure/v1/transformation/pureProtocol/V1_DSLDataSpace_ProtocolHelper.js';
+
+class V1_DataSpaceTaggedValueInfo {
+  profile!: string;
+  tag!: string;
+  value!: string;
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(V1_DataSpaceTaggedValueInfo, {
+      profile: primitive(),
+      tag: primitive(),
+      value: primitive(),
+    }),
+  );
+}
+
+class V1_DataSpaceStereotypeInfo {
+  profile!: string;
+  value!: string;
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(V1_DataSpaceStereotypeInfo, {
+      profile: primitive(),
+      value: primitive(),
+    }),
+  );
+}
+
+class V1_DataSpaceExecutionContextAnalysisResult {
+  name!: string;
+  description?: string | undefined;
+  mapping!: string;
+  defaultRuntime!: string;
+  compatibleRuntimes!: string[];
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(V1_DataSpaceExecutionContextAnalysisResult, {
+      name: primitive(),
+      description: optional(primitive()),
+      mapping: primitive(),
+      defaultRuntime: primitive(),
+      compatibleRuntimes: list(primitive()),
+    }),
+  );
+}
+
+export class V1_DataSpaceAnalysisResult {
+  name!: string;
+  package!: string;
+  path!: string;
+
+  taggedValues: V1_DataSpaceTaggedValueInfo[] = [];
+  stereotypes: V1_DataSpaceStereotypeInfo[] = [];
+
+  description?: string | undefined;
+  supportInfo?: V1_DataSpaceSupportInfo | undefined;
+
+  model!: V1_PureModelContextData;
+
+  executionContexts: V1_DataSpaceExecutionContextAnalysisResult[] = [];
+  defaultExecutionContext!: string;
+
+  featuredDiagrams: string[] = [];
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(V1_DataSpaceAnalysisResult, {
+      name: primitive(),
+      package: primitive(),
+      path: primitive(),
+
+      taggedValues: list(object(V1_DataSpaceTaggedValueInfo)),
+      stereotypes: list(object(V1_DataSpaceStereotypeInfo)),
+
+      description: optional(primitive()),
+      supportInfo: optionalCustom(
+        () => SKIP,
+        (val) => V1_deserializeSupportInfo(val),
+      ),
+
+      model: object(V1_PureModelContextData),
+
+      executionContexts: list(
+        object(V1_DataSpaceExecutionContextAnalysisResult),
+      ),
+      defaultExecutionContext: primitive(),
+
+      featuredDiagrams: list(primitive()),
+    }),
+  );
+}

package/src/{models/protocols → graphManager/protocol}/pure/v1/model/packageableElements/dataSpace/V1_DSLDataSpace_DataSpace.ts

@@ -15,7 +15,7 @@
  */
 
 import { hashArray, type Hashable } from '@finos/legend-shared';
-import { DATA_SPACE_HASH_STRUCTURE } from '../../../../../../DSLDataSpace_ModelUtils.js';
+import { DATA_SPACE_HASH_STRUCTURE } from '../../../../../../../graph/DSLDataSpace_HashUtils.js';
 import {
   V1_PackageableElement,
   type V1_PackageableElementPointer,

package/src/{models/protocols → graphManager/protocol}/pure/v1/transformation/pureGraph/V1_DSLDataSpace_GraphBuilderHelper.ts

@@ -15,7 +15,7 @@
  */
 
 import { getDataSpace } from '../../../../../../graphManager/DSLDataSpace_GraphManagerHelper.js';
-import type { DataSpace } from '../../../../../metamodels/pure/model/packageableElements/dataSpace/DSLDataSpace_DataSpace.js';
+import type { DataSpace } from '../../../../../../graph/metamodel/pure/model/packageableElements/dataSpace/DSLDataSpace_DataSpace.js';
 import type {
   PackageableElementImplicitReference,
   V1_GraphBuilderContext,

package/src/{models/protocols → graphManager/protocol}/pure/v1/transformation/pureProtocol/V1_DSLDataSpace_ProtocolHelper.ts

@@ -78,7 +78,7 @@ const V1_serializeSupportInfo = (
   throw new UnsupportedOperationError(`Can't serialize support info`, protocol);
 };
 
-const V1_deserializeSupportInfo = (
+export const V1_deserializeSupportInfo = (
   json: PlainObject<V1_DataSpaceSupportInfo> | undefined,
 ): V1_DataSpaceSupportInfo | undefined => {
   if (!json) {

package/src/index.ts

@@ -15,16 +15,18 @@
  */
 
 export * from './DSLDataSpace_Extension.js';
-export { DSLDataSpace_LegendStudioPlugin } from './components/studio/DSLDataSpace_LegendStudioPlugin.js';
-export { DSLDataSpace_LegendQueryPlugin } from './components/query/DSLDataSpace_LegendQueryPlugin.js';
+export { DSLDataSpace_LegendStudioApplicationPlugin } from './components/studio/DSLDataSpace_LegendStudioApplicationPlugin.js';
+export { DSLDataSpace_LegendQueryApplicationPlugin } from './components/query/DSLDataSpace_LegendQueryApplicationPlugin.js';
 
 export { DataSpaceViewer } from './components/DataSpaceViewer.js';
 
 export {
   DATA_SPACE_ELEMENT_CLASSIFIER_PATH,
   extractDataSpaceTaxonomyNodes,
-} from './models/protocols/pure/DSLDataSpace_PureProtocolProcessorPlugin.js';
+} from './graphManager/protocol/pure/DSLDataSpace_PureProtocolProcessorPlugin.js';
 
 export { DataSpaceViewerState } from './stores/DataSpaceViewerState.js';
 
 export * from './graphManager/DSLDataSpace_GraphManagerHelper.js';
+export { getDSLDataSpaceGraphManagerExtension } from './graphManager/protocol/pure/DSLDataSpace_PureGraphManagerExtension.js';
+export { DataSpaceAnalysisResult } from './graphManager/action/analytics/DataSpaceAnalysis.js';