@finos/legend-extension-dsl-data-space 0.0.6 → 1.0.1

package/src/components/query/DataSpaceQuerySetup.tsx

@@ -0,0 +1,234 @@
+/**
+ * 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 { useApplicationStore } from '@finos/legend-application';
+import type { SelectComponent } from '@finos/legend-art';
+import {
+  BoltIcon,
+  ArrowRightIcon,
+  clsx,
+  BlankPanelContent,
+  TimesCircleIcon,
+  PanelLoadingIndicator,
+  ArrowLeftIcon,
+  CustomSelectorInput,
+  SearchIcon,
+} from '@finos/legend-art';
+import { useQuerySetupStore, useLegendQueryStore } from '@finos/legend-query';
+import { generateGAVCoordinates } from '@finos/legend-server-depot';
+import { debounce } from '@finos/legend-shared';
+import { flowResult } from 'mobx';
+import { observer } from 'mobx-react-lite';
+import { useEffect, useMemo, useRef, useState } from 'react';
+import type {
+  DataSpaceQuerySetupState,
+  LightDataSpace,
+} from '../../stores/query/DataSpaceQuerySetupState';
+import { DataSpaceViewer } from '../DataSpaceViewer';
+
+type DataSpaceOption = { label: string; value: LightDataSpace };
+const buildDataSpaceOption = (dataSpace: LightDataSpace): DataSpaceOption => ({
+  label: dataSpace.path,
+  value: dataSpace,
+});
+
+export const DataspaceQuerySetup = observer(
+  (props: { querySetupState: DataSpaceQuerySetupState }) => {
+    const { querySetupState } = props;
+    const applicationStore = useApplicationStore();
+    const setupStore = useQuerySetupStore();
+    const queryStore = useLegendQueryStore();
+    const dataSpaceSearchRef = useRef<SelectComponent>(null);
+    const [searchText, setSearchText] = useState('');
+
+    const toggleGetSnapshot = (): void => {
+      querySetupState.setToGetSnapShot(!querySetupState.toGetSnapShot);
+      flowResult(querySetupState.loadDataSpaces(searchText)).catch(
+        applicationStore.alertIllegalUnhandledError,
+      );
+    };
+
+    const next = (): void => {
+      if (querySetupState.dataSpaceViewerState) {
+        flowResult(querySetupState.proceedToCreateQuery()).catch(
+          applicationStore.alertIllegalUnhandledError,
+        );
+      }
+    };
+    const canProceed = querySetupState.dataSpaceViewerState;
+
+    const back = (): void => {
+      setupStore.setSetupState(undefined);
+      querySetupState.setCurrentDataSpace(undefined);
+      queryStore.graphManagerState.resetGraph();
+    };
+
+    // query
+    const dataSpaceOptions =
+      querySetupState.dataSpaces.map(buildDataSpaceOption);
+    const selectedDataSpaceOption = querySetupState.currentDataSpace
+      ? buildDataSpaceOption(querySetupState.currentDataSpace)
+      : null;
+    const onDataSpaceOptionChange = (option: DataSpaceOption | null): void => {
+      if (option?.value !== querySetupState.currentDataSpace) {
+        queryStore.graphManagerState.resetGraph();
+        querySetupState.setCurrentDataSpace(option?.value);
+        querySetupState.setDataSpaceViewerState(undefined);
+      }
+    };
+    const formatQueryOptionLabel = (
+      option: DataSpaceOption,
+    ): React.ReactNode => (
+      <div className="query-setup__data-space__option">
+        <div className="query-setup__data-space__option__label">
+          {option.label}
+        </div>
+        <div className="query-setup__data-space__option__gav">
+          {generateGAVCoordinates(
+            option.value.groupId,
+            option.value.artifactId,
+            option.value.versionId,
+          )}
+        </div>
+      </div>
+    );
+
+    // search text
+    const debouncedLoadDataSpaces = useMemo(
+      () =>
+        debounce((input: string): void => {
+          flowResult(querySetupState.loadDataSpaces(input)).catch(
+            applicationStore.alertIllegalUnhandledError,
+          );
+        }, 500),
+      [applicationStore, querySetupState],
+    );
+    const onSearchTextChange = (value: string): void => {
+      if (value !== searchText) {
+        setSearchText(value);
+        debouncedLoadDataSpaces.cancel();
+        debouncedLoadDataSpaces(value);
+      }
+    };
+
+    useEffect(() => {
+      flowResult(querySetupState.loadDataSpaces('')).catch(
+        applicationStore.alertIllegalUnhandledError,
+      );
+    }, [querySetupState, applicationStore]);
+
+    useEffect(() => {
+      if (querySetupState.currentDataSpace) {
+        flowResult(
+          querySetupState.setUpDataSpace(querySetupState.currentDataSpace),
+        ).catch(applicationStore.alertIllegalUnhandledError);
+      }
+    }, [querySetupState, applicationStore, querySetupState.currentDataSpace]);
+
+    useEffect(() => {
+      dataSpaceSearchRef.current?.focus();
+    }, []);
+
+    return (
+      <div className="query-setup__wizard query-setup__data-space">
+        <div className="query-setup__wizard__header query-setup__data-space__header">
+          <button
+            className="query-setup__wizard__header__btn"
+            onClick={back}
+            title="Back to Main Menu"
+          >
+            <ArrowLeftIcon />
+          </button>
+          <div className="query-setup__wizard__header__title">
+            Creating query from data space...
+          </div>
+          <button
+            className={clsx('query-setup__wizard__header__btn', {
+              'query-setup__wizard__header__btn--ready': canProceed,
+            })}
+            onClick={next}
+            disabled={!canProceed}
+            title="Proceed"
+          >
+            <ArrowRightIcon />
+          </button>
+        </div>
+        <div className="query-setup__wizard__content">
+          <div className="query-setup__wizard__group query-setup__wizard__group--inline query-setup__data-space__input-group">
+            <div className="query-setup__wizard__group__title">
+              <SearchIcon />
+            </div>
+            <CustomSelectorInput
+              ref={dataSpaceSearchRef}
+              className="query-setup__wizard__selector"
+              options={dataSpaceOptions}
+              isLoading={querySetupState.loadDataSpacesState.isInProgress}
+              onInputChange={onSearchTextChange}
+              inputValue={searchText}
+              onChange={onDataSpaceOptionChange}
+              value={selectedDataSpaceOption}
+              placeholder="Search for data space by name..."
+              isClearable={true}
+              escapeClearsValue={true}
+              darkMode={true}
+              formatOptionLabel={formatQueryOptionLabel}
+            />
+            <button
+              className={clsx('query-setup__data-space__use-snapshot-btn', {
+                'query-setup__data-space__use-snapshot-btn--active':
+                  querySetupState.toGetSnapShot,
+              })}
+              tabIndex={-1}
+              title={`[${
+                querySetupState.toGetSnapShot ? 'on' : 'off'
+              }] Toggle show data spaces from snapshot releases instead of latest releases`}
+              onClick={toggleGetSnapshot}
+            >
+              <BoltIcon />
+            </button>
+          </div>
+          <div className="query-setup__data-space__view">
+            <PanelLoadingIndicator
+              isLoading={querySetupState.setUpDataSpaceState.isInProgress}
+            />
+            {querySetupState.dataSpaceViewerState && (
+              <DataSpaceViewer
+                dataSpaceViewerState={querySetupState.dataSpaceViewerState}
+              />
+            )}
+            {!querySetupState.dataSpaceViewerState &&
+              querySetupState.setUpDataSpaceState.isInProgress && (
+                <BlankPanelContent>Setting up data space...</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 />
+                    </div>
+                    <div className="query-setup__data-space__view--failed__text">
+                      Can&apos;t load data space
+                    </div>
+                  </div>
+                </BlankPanelContent>
+              )}
+          </div>
+        </div>
+      </div>
+    );
+  },
+);

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

@@ -16,41 +16,42 @@
 
 import packageJson from '../../../package.json';
 import type {
-  StudioPluginManager,
+  LegendStudioPluginManager,
   NewElementFromStateCreator,
-  EditorStore,
-  ElementEditorState,
-  ElementEditorStateCreator,
   ElementTypeGetter,
   ElementProjectExplorerDnDTypeGetter,
   ElementIconGetter,
-  DSL_StudioPlugin_Extension,
+  DSL_LegendStudioPlugin_Extension,
   NewElementState,
-  ElementEditorRenderer,
+  ElementEditorStateCreator,
+  EditorStore,
+  ElementEditorState,
+} from '@finos/legend-studio';
+import {
+  UnsupportedElementEditorState,
+  LegendStudioPlugin,
 } from '@finos/legend-studio';
-import { StudioPlugin } from '@finos/legend-studio';
 import { SquareIcon } from '@finos/legend-art';
 import type { PackageableElement } from '@finos/legend-graph';
 import {
   DataSpace,
   DataSpaceExecutionContext,
 } from '../../models/metamodels/pure/model/packageableElements/dataSpace/DataSpace';
-import { DataSpaceEditorState } from '../../stores/studio/DataSpaceEditorState';
-import { DataSpaceViewer } from './DataSpaceEditor';
+import { LATEST_VERSION_ALIAS } from '@finos/legend-server-depot';
 
 const DATA_SPACE_ELEMENT_TYPE = 'DATA SPACE';
 const DATA_SPACE_ELEMENT_PROJECT_EXPLORER_DND_TYPE =
   'PROJECT_EXPLORER_DATA_SPACE';
 
-export class DSLDataSpace_StudioPlugin
-  extends StudioPlugin
-  implements DSL_StudioPlugin_Extension
+export class DSLDataSpace_LegendStudioPlugin
+  extends LegendStudioPlugin
+  implements DSL_LegendStudioPlugin_Extension
 {
   constructor() {
     super(packageJson.extensions.studioPlugin, packageJson.version);
   }
 
-  install(pluginManager: StudioPluginManager): void {
+  install(pluginManager: LegendStudioPluginManager): void {
     pluginManager.registerStudioPlugin(this);
   }
 
@@ -74,7 +75,7 @@ export class DSLDataSpace_StudioPlugin
       (type: string): React.ReactNode | undefined => {
         if (type === DATA_SPACE_ELEMENT_TYPE) {
           return (
-            <div className="icon icon--text-element">
+            <div className="icon icon--data-space">
               <SquareIcon />
             </div>
           );
@@ -84,17 +85,6 @@ export class DSLDataSpace_StudioPlugin
     ];
   }
 
-  getExtraElementEditorRenderers(): ElementEditorRenderer[] {
-    return [
-      (elementEditorState: ElementEditorState): React.ReactNode | undefined => {
-        if (elementEditorState instanceof DataSpaceEditorState) {
-          return <DataSpaceViewer key={elementEditorState.uuid} />;
-        }
-        return undefined;
-      },
-    ];
-  }
-
   getExtraNewElementFromStateCreators(): NewElementFromStateCreator[] {
     return [
       (
@@ -108,7 +98,7 @@ export class DSLDataSpace_StudioPlugin
             state.editorStore.projectConfigurationEditorState.currentProjectConfiguration.groupId;
           dataSpace.artifactId =
             state.editorStore.projectConfigurationEditorState.currentProjectConfiguration.artifactId;
-          dataSpace.versionId = 'latest';
+          dataSpace.versionId = LATEST_VERSION_ALIAS;
           const dataSpaceExecutionContext = new DataSpaceExecutionContext();
           dataSpaceExecutionContext.name = 'dummyContext';
           dataSpaceExecutionContext.mapping = 'dummyMapping';
@@ -129,7 +119,7 @@ export class DSLDataSpace_StudioPlugin
         element: PackageableElement,
       ): ElementEditorState | undefined => {
         if (element instanceof DataSpace) {
-          return new DataSpaceEditorState(editorStore, element);
+          return new UnsupportedElementEditorState(editorStore, element);
         }
         return undefined;
       },

package/src/graph/DSLDataSpace_PureGraphPlugin.ts

@@ -29,7 +29,7 @@ export class DSLDataSpace_PureGraphPlugin extends PureGraphPlugin {
   }
 
   install(pluginManager: GraphPluginManager): void {
-    pluginManager.registerPureGraphPlugins(this);
+    pluginManager.registerPureGraphPlugin(this);
   }
 
   override getExtraPureGraphExtensionClasses(): Clazz<PackageableElement>[] {

package/src/index.ts

@@ -15,3 +15,15 @@
  */
 
 export * from './DSLDataSpace_Extension';
+export { DSLDataSpace_LegendStudioPlugin } from './components/studio/DSLDataSpace_LegendStudioPlugin';
+export { DSLDataSpace_LegendQueryPlugin } from './components/query/DSLDataSpace_LegendQueryPlugin';
+
+export { DataSpaceViewer } from './components/DataSpaceViewer';
+
+export {
+  DATA_SPACE_ELEMENT_CLASSIFIER_PATH,
+  extractDataSpaceTaxonomyNodes,
+  getResolvedDataSpace,
+} from './models/protocols/pure/DSLDataSpace_PureProtocolProcessorPlugin';
+
+export { DataSpaceViewerState } from './stores/DataSpaceViewerState';

package/src/models/protocols/pure/DSLDataSpace_PureProtocolProcessorPlugin.ts

@@ -23,6 +23,7 @@ import {
 } from './v1/model/packageableElements/dataSpace/V1_DataSpace';
 import type { PlainObject } from '@finos/legend-shared';
 import {
+  uuid,
   guaranteeNonEmptyString,
   guaranteeNonNullable,
   UnsupportedOperationError,
@@ -35,6 +36,7 @@ import {
   V1_DATA_SPACE_ELEMENT_PROTOCOL_TYPE,
 } from './v1/transformation/pureProtocol/V1_DSLDataSpace_ProtocolHelper';
 import { getDataSpace } from '../../../graphManager/DSLDataSpace_GraphManagerHelper';
+import type { DataSpaceSupportInfo } from '../../metamodels/pure/model/packageableElements/dataSpace/DataSpace';
 import {
   DataSpace,
   DataSpaceExecutionContext,
@@ -42,7 +44,11 @@ import {
 } from '../../metamodels/pure/model/packageableElements/dataSpace/DataSpace';
 import type {
   GraphPluginManager,
+  Mapping,
   PackageableElement,
+  PackageableElementReference,
+  PackageableRuntime,
+  PureModel,
   V1_ElementProtocolClassifierPathGetter,
   V1_ElementProtocolDeserializer,
   V1_ElementProtocolSerializer,
@@ -51,8 +57,11 @@ import type {
   V1_GraphTransformerContext,
   V1_PackageableElement,
   V1_PureModelContextData,
+  V1_TaggedValue,
 } from '@finos/legend-graph';
 import {
+  V1_taggedValueSchema,
+  PackageableElementExplicitReference,
   V1_PackageableElementPointer,
   V1_PackageableElementPointerType,
   V1_buildTaggedValue,
@@ -61,10 +70,14 @@ import {
   PureProtocolProcessorPlugin,
   V1_ElementBuilder,
   V1_initPackageableElement,
+  V1_StereotypePtr,
 } from '@finos/legend-graph';
-import { V1_DSLDiagram_PackageableElementPointerType } from '@finos/legend-extension-dsl-diagram';
+import {
+  Diagram,
+  V1_DSLDiagram_PackageableElementPointerType,
+} from '@finos/legend-extension-dsl-diagram';
 
-const DATA_SPACE_ELEMENT_CLASSIFIER_PATH =
+export const DATA_SPACE_ELEMENT_CLASSIFIER_PATH =
   'meta::pure::metamodel::dataSpace::DataSpace';
 
 export class DSLDataSpace_PureProtocolProcessorPlugin extends PureProtocolProcessorPlugin {
@@ -161,15 +174,20 @@ export class DSLDataSpace_PureProtocolProcessorPlugin extends PureProtocolProces
             `Can't find default execution context '${elementProtocol.defaultExecutionContext}'`,
           );
           element.description = elementProtocol.description;
-          element.featuredDiagrams = (
-            elementProtocol.featuredDiagrams ?? []
-          ).map((pointer) => pointer.path);
+          if (elementProtocol.featuredDiagrams) {
+            element.featuredDiagrams = elementProtocol.featuredDiagrams.map(
+              (pointer) => pointer.path,
+            );
+          }
           if (elementProtocol.supportInfo) {
             if (
               elementProtocol.supportInfo instanceof V1_DataSpaceSupportEmail
             ) {
               const supportEmail = new DataSpaceSupportEmail();
-              supportEmail.address = elementProtocol.supportInfo.address;
+              supportEmail.address = guaranteeNonEmptyString(
+                elementProtocol.supportInfo.address,
+                `Data space support email 'address' field is missing or empty`,
+              );
               element.supportInfo = supportEmail;
             } else {
               throw new UnsupportedOperationError(
@@ -202,6 +220,7 @@ export class DSLDataSpace_PureProtocolProcessorPlugin extends PureProtocolProces
     return [
       (
         elementProtocol: V1_PackageableElement,
+        plugins: PureProtocolProcessorPlugin[],
       ): PlainObject<V1_PackageableElement> | undefined => {
         if (elementProtocol instanceof V1_DataSpace) {
           return serialize(V1_dataSpaceModelSchema, elementProtocol);
@@ -215,6 +234,7 @@ export class DSLDataSpace_PureProtocolProcessorPlugin extends PureProtocolProces
     return [
       (
         json: PlainObject<V1_PackageableElement>,
+        plugins: PureProtocolProcessorPlugin[],
       ): V1_PackageableElement | undefined => {
         if (json._type === V1_DATA_SPACE_ELEMENT_PROTOCOL_TYPE) {
           return deserialize(V1_dataSpaceModelSchema, json);
@@ -288,3 +308,169 @@ export class DSLDataSpace_PureProtocolProcessorPlugin extends PureProtocolProces
     ];
   }
 }
+
+export class ResolvedDataSpaceExecutionContext {
+  name!: string;
+  description?: string | undefined;
+  mapping!: PackageableElementReference<Mapping>;
+  defaultRuntime!: PackageableElementReference<PackageableRuntime>;
+}
+
+/**
+ * When we actually need to use the data space, we want to resolve all of its
+ * element pointers to actual reference, hence this model.
+ */
+export class ResolvedDataSpace {
+  taggedValues: {
+    uuid: string;
+    profile: string;
+    tag: string;
+    value: string;
+  }[] = [];
+  stereotypes: { uuid: string; profile: string; stereotype: string }[] = [];
+  path!: string;
+  groupId!: string;
+  artifactId!: string;
+  versionId!: string;
+  executionContexts: ResolvedDataSpaceExecutionContext[] = [];
+  defaultExecutionContext!: ResolvedDataSpaceExecutionContext;
+  featuredDiagrams: PackageableElementReference<Diagram>[] = [];
+  description?: string | undefined;
+  supportInfo?: DataSpaceSupportInfo | undefined;
+}
+
+export const getResolvedDataSpace = (
+  json: PlainObject<V1_DataSpace>,
+  graph: PureModel,
+): ResolvedDataSpace => {
+  const dataSpace = new ResolvedDataSpace();
+  if (json._type === V1_DATA_SPACE_ELEMENT_PROTOCOL_TYPE) {
+    const protocol = deserialize(V1_dataSpaceModelSchema, json);
+    dataSpace.path = protocol.path;
+    if (Array.isArray(json.taggedValues)) {
+      dataSpace.taggedValues = (
+        json.taggedValues as PlainObject<V1_TaggedValue>[]
+      )
+        .map((taggedValueJson) =>
+          deserialize(V1_taggedValueSchema, taggedValueJson),
+        )
+        .map((taggedValue) => ({
+          uuid: uuid(),
+          profile: taggedValue.tag.profile,
+          tag: taggedValue.tag.value,
+          value: taggedValue.value,
+        }));
+    }
+    if (Array.isArray(json.stereotypes)) {
+      dataSpace.stereotypes = (
+        json.stereotypes as PlainObject<V1_StereotypePtr>[]
+      )
+        .map((stereotypePtrJson) =>
+          deserialize(V1_StereotypePtr, stereotypePtrJson),
+        )
+        .map((stereotypePtr) => ({
+          uuid: uuid(),
+          profile: stereotypePtr.profile,
+          stereotype: stereotypePtr.value,
+        }));
+    }
+    dataSpace.groupId = guaranteeNonEmptyString(
+      protocol.groupId,
+      `Data space 'groupId' field is missing or empty`,
+    );
+    dataSpace.artifactId = guaranteeNonEmptyString(
+      protocol.artifactId,
+      `Data space 'artifactId' field is missing or empty`,
+    );
+    dataSpace.versionId = guaranteeNonEmptyString(
+      protocol.versionId,
+      `Data space 'versionId' field is missing or empty`,
+    );
+    dataSpace.executionContexts = protocol.executionContexts.map(
+      (contextProtocol) => {
+        const context = new ResolvedDataSpaceExecutionContext();
+        context.name = guaranteeNonEmptyString(
+          contextProtocol.name,
+          `Data space execution context 'name' field is missing or empty`,
+        );
+        context.description = contextProtocol.description;
+        context.mapping = PackageableElementExplicitReference.create(
+          graph.getMapping(contextProtocol.mapping.path),
+        );
+        context.defaultRuntime = PackageableElementExplicitReference.create(
+          graph.getRuntime(contextProtocol.defaultRuntime.path),
+        );
+        return context;
+      },
+    );
+    dataSpace.defaultExecutionContext = guaranteeNonNullable(
+      dataSpace.executionContexts.find(
+        (context) =>
+          context.name ===
+          guaranteeNonEmptyString(
+            protocol.defaultExecutionContext,
+            `Data space 'defaultExecutionContext' field is missing or empty`,
+          ),
+      ),
+      `Can't find default execution context '${protocol.defaultExecutionContext}'`,
+    );
+    dataSpace.description = protocol.description;
+    if (protocol.featuredDiagrams) {
+      dataSpace.featuredDiagrams = protocol.featuredDiagrams.map((pointer) =>
+        PackageableElementExplicitReference.create(
+          graph.getExtensionElement(pointer.path, Diagram),
+        ),
+      );
+    }
+    if (protocol.supportInfo) {
+      if (protocol.supportInfo instanceof V1_DataSpaceSupportEmail) {
+        const supportEmail = new DataSpaceSupportEmail();
+        supportEmail.address = guaranteeNonEmptyString(
+          protocol.supportInfo.address,
+          `Data space support email 'address' field is missing or empty`,
+        );
+        dataSpace.supportInfo = supportEmail;
+      } else {
+        throw new UnsupportedOperationError(
+          `Can't build data space support info`,
+          protocol.supportInfo,
+        );
+      }
+    }
+    return dataSpace;
+  }
+  throw new UnsupportedOperationError(`Can't resolve data space`, json);
+};
+
+export const extractDataSpaceTaxonomyNodes = (
+  json: PlainObject<V1_DataSpace>,
+): string[] => {
+  const ENTERPRISE_PROFILE_PATH = `meta::pure::profiles::enterprise`;
+  const TAXONOMY_NODES_TAG = `taxonomyNodes`;
+  const TAXONOMY_NODES_TAG_VALUE_DELIMITER = `,`;
+
+  const taxonomyNodes = new Set<string>();
+  if (json._type === V1_DATA_SPACE_ELEMENT_PROTOCOL_TYPE) {
+    if (Array.isArray(json.taggedValues)) {
+      const taggedValues = (
+        json.taggedValues as PlainObject<V1_TaggedValue>[]
+      ).map((taggedValueJson) =>
+        deserialize(V1_taggedValueSchema, taggedValueJson),
+      );
+      taggedValues
+        .filter(
+          (taggedValue) =>
+            taggedValue.tag.profile === ENTERPRISE_PROFILE_PATH &&
+            taggedValue.tag.value === TAXONOMY_NODES_TAG,
+        )
+        .forEach((taggedValue) => {
+          taggedValue.value
+            .split(TAXONOMY_NODES_TAG_VALUE_DELIMITER)
+            .map((value) => value.trim())
+            .filter((value) => Boolean(value))
+            .forEach((value) => taxonomyNodes.add(value));
+        });
+    }
+  }
+  return Array.from(taxonomyNodes.values());
+};

package/src/models/protocols/pure/v1/transformation/pureProtocol/V1_DSLDataSpace_ProtocolHelper.ts

@@ -47,7 +47,7 @@ import {
 } from '../../model/packageableElements/dataSpace/V1_DataSpace';
 
 export const V1_DATA_SPACE_ELEMENT_PROTOCOL_TYPE = 'dataSpace';
-const V1_DATA_SPACE_SUPPORT_EMAIL_TYPE = 'email';
+export const V1_DATA_SPACE_SUPPORT_EMAIL_TYPE = 'email';
 
 const V1_dataSpaceExecutionContextModelSchema = createModelSchema(
   V1_DataSpaceExecutionContext,