@finos/legend-extension-dsl-data-space 0.0.1

package/src/components/studio/DataSpaceEditor.tsx

@@ -0,0 +1,275 @@
+/**
+ * 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 { useRef, useEffect } from 'react';
+import { observer } from 'mobx-react-lite';
+import { useEditorStore } from '@finos/legend-studio';
+import { useResizeDetector } from 'react-resize-detector';
+import {
+  BlankPanelContent,
+  ShapesIcon,
+  PlayIcon,
+  UserIcon,
+  QuestionCircleIcon,
+  clsx,
+  EnvelopIcon,
+  MappingIcon,
+  RuntimeIcon,
+  CustomSelectorInput,
+} from '@finos/legend-art';
+import {
+  DataSpaceEditorState,
+  DATA_SPACE_VIEWER_ACTIVITY_MODE,
+} from '../../stores/studio/DataSpaceEditorState';
+import type { Diagram } from '@finos/legend-extension-dsl-diagram';
+import { DiagramRenderer } from '@finos/legend-extension-dsl-diagram';
+
+interface DataSpaceViewerActivityConfig {
+  mode: DATA_SPACE_VIEWER_ACTIVITY_MODE;
+  title: string;
+  icon: React.ReactElement;
+}
+
+const DataSpaceDiagramCanvas = observer(
+  (
+    props: {
+      dataSpaceEditorState: DataSpaceEditorState;
+      diagram: Diagram;
+    },
+    ref: React.Ref<HTMLDivElement>,
+  ) => {
+    const { dataSpaceEditorState, diagram } = props;
+    const diagramCanvasRef =
+      ref as React.MutableRefObject<HTMLDivElement | null>;
+
+    const { width, height } = useResizeDetector<HTMLDivElement>({
+      refreshMode: 'debounce',
+      refreshRate: 50,
+      targetRef: diagramCanvasRef,
+    });
+
+    useEffect(() => {
+      if (diagramCanvasRef.current) {
+        const renderer = new DiagramRenderer(diagramCanvasRef.current, diagram);
+        dataSpaceEditorState.setRenderer(renderer);
+        renderer.render();
+        renderer.autoRecenter();
+      }
+    }, [diagramCanvasRef, dataSpaceEditorState, diagram]);
+
+    useEffect(() => {
+      if (dataSpaceEditorState.isDiagramRendererInitialized) {
+        dataSpaceEditorState.renderer.refresh();
+      }
+    }, [dataSpaceEditorState, width, height]);
+
+    return (
+      <div
+        ref={diagramCanvasRef}
+        className="diagram-canvas"
+        tabIndex={0}
+        onContextMenu={(event): void => event.preventDefault()}
+      />
+    );
+  },
+  { forwardRef: true },
+);
+
+type DiagramOption = { label: string; value: Diagram };
+const buildDiagramOption = (diagram: Diagram): DiagramOption => ({
+  label: diagram.name,
+  value: diagram,
+});
+
+const DataSpaceModelsOverview = observer(
+  (props: { dataSpaceEditorState: DataSpaceEditorState }) => {
+    const { dataSpaceEditorState } = props;
+    const diagramCanvasRef = useRef<HTMLDivElement>(null);
+    const diagramOptions =
+      dataSpaceEditorState.diagrams.map(buildDiagramOption);
+    const selectedDiagramOption = dataSpaceEditorState.currentDiagram
+      ? buildDiagramOption(dataSpaceEditorState.currentDiagram)
+      : null;
+    const onDiagramOptionChange = (option: DiagramOption): void => {
+      if (option.value !== dataSpaceEditorState.currentDiagram) {
+        dataSpaceEditorState.setCurrentDiagram(option.value);
+      }
+    };
+
+    return (
+      <>
+        {dataSpaceEditorState.diagrams.length !== 0 && (
+          <div className="data-space-viewer__main-panel__content data-space-viewer__overview-panel">
+            <div className="data-space-viewer__overview-panel__header">
+              <CustomSelectorInput
+                className="data-space-viewer__overview-panel__diagram-selector"
+                options={diagramOptions}
+                onChange={onDiagramOptionChange}
+                value={selectedDiagramOption}
+                placeholder="Search for a diagram"
+                darkMode={true}
+              />
+            </div>
+            <div className="data-space-viewer__overview-panel__content">
+              {dataSpaceEditorState.currentDiagram && (
+                <DataSpaceDiagramCanvas
+                  dataSpaceEditorState={dataSpaceEditorState}
+                  diagram={dataSpaceEditorState.currentDiagram}
+                  ref={diagramCanvasRef}
+                />
+              )}
+            </div>
+          </div>
+        )}
+        {dataSpaceEditorState.diagrams.length === 0 && (
+          <BlankPanelContent>No diagrams available</BlankPanelContent>
+        )}
+      </>
+    );
+  },
+);
+
+export const DataSpaceViewer = observer(() => {
+  const editorStore = useEditorStore();
+  const dataSpaceEditorState =
+    editorStore.getCurrentEditorState(DataSpaceEditorState);
+  const dataSpace = dataSpaceEditorState.dataSpace;
+  const changeActivity =
+    (activity: DATA_SPACE_VIEWER_ACTIVITY_MODE): (() => void) =>
+    (): void =>
+      dataSpaceEditorState.setCurrentActivity(activity);
+
+  const activities: DataSpaceViewerActivityConfig[] = [
+    {
+      mode: DATA_SPACE_VIEWER_ACTIVITY_MODE.MODELS,
+      title: 'Models Overview',
+      icon: <ShapesIcon />,
+    },
+    {
+      mode: DATA_SPACE_VIEWER_ACTIVITY_MODE.EXECUTION,
+      title: 'Execution Context',
+      icon: <PlayIcon />,
+    },
+    {
+      mode: DATA_SPACE_VIEWER_ACTIVITY_MODE.ENTITLEMENT,
+      title: 'Entitlement',
+      icon: <UserIcon />,
+    },
+    {
+      mode: DATA_SPACE_VIEWER_ACTIVITY_MODE.SUPPORT,
+      title: 'Support',
+      icon: <QuestionCircleIcon />,
+    },
+  ];
+
+  return (
+    <div className="data-space-viewer">
+      <div className="data-space-viewer__header">
+        <div className="data-space-viewer__path">{dataSpace.path}</div>
+        <div className="data-space-viewer__gav">
+          <div className="data-space-viewer__gav__group-id">
+            {dataSpace.groupId}
+          </div>
+          <div className="data-space-viewer__gav__separator">:</div>
+          <div className="data-space-viewer__gav__artifact-id">
+            {dataSpace.artifactId}
+          </div>
+          <div className="data-space-viewer__gav__separator">:</div>
+          <div className="data-space-viewer__gav__version-id">
+            {dataSpace.versionId}
+          </div>
+        </div>
+        <div className="data-space-viewer__description">
+          {dataSpace.description ? (
+            dataSpace.description
+          ) : (
+            <div className="data-space-viewer__description--empty">
+              No description
+            </div>
+          )}
+        </div>
+      </div>
+      <div className="data-space-viewer__content">
+        <div className="data-space-viewer__body">
+          <div className="data-space-viewer__activity-bar">
+            <div className="data-space-viewer__activity-bar__items">
+              {activities.map((activity) => (
+                <button
+                  key={activity.mode}
+                  className={clsx('data-space-viewer__activity-bar__item', {
+                    'data-space-viewer__activity-bar__item--active':
+                      dataSpaceEditorState.currentActivity === activity.mode,
+                  })}
+                  onClick={changeActivity(activity.mode)}
+                  tabIndex={-1}
+                  title={activity.title}
+                >
+                  {activity.icon}
+                </button>
+              ))}
+            </div>
+          </div>
+          <div className="data-space-viewer__main-panel">
+            {dataSpaceEditorState.currentActivity ===
+              DATA_SPACE_VIEWER_ACTIVITY_MODE.MODELS && (
+              <DataSpaceModelsOverview
+                dataSpaceEditorState={dataSpaceEditorState}
+              />
+            )}
+            {dataSpaceEditorState.currentActivity ===
+              DATA_SPACE_VIEWER_ACTIVITY_MODE.EXECUTION && (
+              <div className="data-space-viewer__main-panel__content data-space-viewer__execution-panel">
+                <div className="data-space-viewer__panel__info-entry">
+                  <div className="data-space-viewer__panel__info-entry__icon">
+                    <MappingIcon />
+                  </div>
+                  <div className="data-space-viewer__panel__info-entry__content">
+                    {dataSpace.mapping}
+                  </div>
+                </div>
+                <div className="data-space-viewer__panel__info-entry">
+                  <div className="data-space-viewer__panel__info-entry__icon">
+                    <RuntimeIcon />
+                  </div>
+                  <div className="data-space-viewer__panel__info-entry__content">
+                    {dataSpace.runtime}
+                  </div>
+                </div>
+              </div>
+            )}
+            {dataSpaceEditorState.currentActivity ===
+              DATA_SPACE_VIEWER_ACTIVITY_MODE.ENTITLEMENT && (
+              <BlankPanelContent>(WIP)</BlankPanelContent>
+            )}
+            {dataSpaceEditorState.currentActivity ===
+              DATA_SPACE_VIEWER_ACTIVITY_MODE.SUPPORT && (
+              <div className="data-space-viewer__main-panel__content data-space-viewer__support-panel">
+                <div className="data-space-viewer__panel__info-entry">
+                  <div className="data-space-viewer__panel__info-entry__icon">
+                    <EnvelopIcon />
+                  </div>
+                  <div className="data-space-viewer__panel__info-entry__content">
+                    {dataSpace.supportEmail ?? '(no support contact available)'}
+                  </div>
+                </div>
+              </div>
+            )}
+          </div>
+        </div>
+      </div>
+    </div>
+  );
+});

package/src/graph/DSLDataSpace_PureGraphPlugin.ts

@@ -0,0 +1,38 @@
+/**
+ * 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 packageJson from '../../package.json';
+import { DataSpace } from '../models/metamodels/pure/model/packageableElements/dataSpace/DataSpace';
+import type { Clazz } from '@finos/legend-shared';
+import type {
+  GraphPluginManager,
+  PackageableElement,
+} from '@finos/legend-graph';
+import { PureGraphPlugin } from '@finos/legend-graph';
+
+export class DSLDataSpace_PureGraphPlugin extends PureGraphPlugin {
+  constructor() {
+    super(packageJson.extensions.pureGraphPlugin, packageJson.version);
+  }
+
+  install(pluginManager: GraphPluginManager): void {
+    pluginManager.registerPureGraphPlugins(this);
+  }
+
+  override getExtraPureGraphExtensionClasses(): Clazz<PackageableElement>[] {
+    return [DataSpace];
+  }
+}

package/src/graphManager/DSLDataSpace_GraphManagerHelper.ts

@@ -0,0 +1,21 @@
+/**
+ * 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 { PureModel } from '@finos/legend-graph';
+import { DataSpace } from '../models/metamodels/pure/model/packageableElements/dataSpace/DataSpace';
+
+export const getDataSpace = (path: string, graph: PureModel): DataSpace =>
+  graph.getExtensionElement(path, DataSpace, `Can't find data space '${path}'`);

package/src/graphManager/DSLDataSpace_PureGraphManagerPlugin.ts

@@ -0,0 +1,56 @@
+/**
+ * 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 packageJson from '../../package.json';
+import { DataSpace } from '../models/metamodels/pure/model/packageableElements/dataSpace/DataSpace';
+import type {
+  GraphPluginManager,
+  PackageableElement,
+  PureGrammarElementLabeler,
+} from '@finos/legend-graph';
+import { PureGraphManagerPlugin } from '@finos/legend-graph';
+
+const PURE_GRAMMAR_DATA_SPACE_PARSER_NAME = 'DataSpace';
+const PURE_GRAMMAR_DATA_SPACE_ELEMENT_TYPE_LABEL = 'DataSpace';
+
+export class DSLDataSpace_PureGraphManagerPlugin extends PureGraphManagerPlugin {
+  constructor() {
+    super(packageJson.extensions.pureGraphManagerPlugin, packageJson.version);
+  }
+
+  install(pluginManager: GraphPluginManager): void {
+    pluginManager.registerPureGraphManagerPlugin(this);
+  }
+
+  override getExtraPureGrammarParserNames(): string[] {
+    return [PURE_GRAMMAR_DATA_SPACE_PARSER_NAME];
+  }
+
+  override getExtraPureGrammarKeywords(): string[] {
+    return [PURE_GRAMMAR_DATA_SPACE_ELEMENT_TYPE_LABEL];
+  }
+
+  override getExtraPureGrammarElementLabelers(): PureGrammarElementLabeler[] {
+    return [
+      (element: PackageableElement): string | undefined => {
+        if (element instanceof DataSpace) {
+          return PURE_GRAMMAR_DATA_SPACE_ELEMENT_TYPE_LABEL;
+        }
+        return undefined;
+      },
+    ];
+  }
+}

package/src/index.ts

@@ -0,0 +1,17 @@
+/**
+ * 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.
+ */
+
+export * from './DSLDataSpace_Extension';

package/src/models/DSLDataSpace_ModelUtils.ts

@@ -0,0 +1,19 @@
+/**
+ * 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.
+ */
+
+export enum DATA_SPACE_HASH_STRUCTURE {
+  DATA_SPACE = 'DATA_SPACE',
+}

package/src/models/metamodels/pure/model/packageableElements/dataSpace/DataSpace.ts

@@ -0,0 +1,73 @@
+/**
+ * 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 { makeObservable, override } from 'mobx';
+import { hashArray } from '@finos/legend-shared';
+import type { Hashable } from '@finos/legend-shared';
+import type {
+  PackageableElementVisitor,
+  StereotypeReference,
+  TaggedValue,
+} from '@finos/legend-graph';
+import { PackageableElement } from '@finos/legend-graph';
+import { DATA_SPACE_HASH_STRUCTURE } from '../../../../../DSLDataSpace_ModelUtils';
+
+export class DataSpace extends PackageableElement implements Hashable {
+  stereotypes: StereotypeReference[] = [];
+  taggedValues: TaggedValue[] = [];
+  groupId!: string;
+  artifactId!: string;
+  versionId!: string;
+  mapping!: string;
+  runtime!: string;
+  diagrams: string[] = [];
+  description?: string | undefined;
+  // NOTE: we're not too sure about this attribute. We feel that this would be needed but maybe
+  // we can think of a more generic strategy for this type of metadata
+  supportEmail?: string | undefined;
+
+  constructor(name: string) {
+    super(name);
+
+    makeObservable<DataSpace, '_elementHashCode'>(this, {
+      _elementHashCode: override,
+    });
+  }
+
+  protected override get _elementHashCode(): string {
+    return hashArray([
+      DATA_SPACE_HASH_STRUCTURE.DATA_SPACE,
+      hashArray(
+        this.stereotypes.map((stereotype) => stereotype.pointerHashCode),
+      ),
+      hashArray(this.taggedValues),
+      this.groupId,
+      this.artifactId,
+      this.versionId,
+      this.mapping,
+      this.runtime,
+      hashArray(this.diagrams),
+      this.description ?? '',
+      this.supportEmail ?? '',
+    ]);
+  }
+
+  accept_PackageableElementVisitor<T>(
+    visitor: PackageableElementVisitor<T>,
+  ): T {
+    return visitor.visit_PackageableElement(this);
+  }
+}

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

@@ -0,0 +1,180 @@
+/**
+ * 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 packageJson from '../../../../package.json';
+import { V1_DataSpace } from './v1/model/packageableElements/dataSpace/V1_DataSpace';
+import type { PlainObject } from '@finos/legend-shared';
+import { isNonNullable, assertType } from '@finos/legend-shared';
+import { deserialize, serialize } from 'serializr';
+import {
+  V1_dataSpaceModelSchema,
+  V1_DATA_SPACE_ELEMENT_PROTOCOL_TYPE,
+} from './v1/transformation/pureProtocol/V1_DSLDataSpace_ProtocolHelper';
+import { getDataSpace } from '../../../graphManager/DSLDataSpace_GraphManagerHelper';
+import { DataSpace } from '../../metamodels/pure/model/packageableElements/dataSpace/DataSpace';
+import type {
+  GraphPluginManager,
+  PackageableElement,
+  V1_ElementProtocolClassifierPathGetter,
+  V1_ElementProtocolDeserializer,
+  V1_ElementProtocolSerializer,
+  V1_ElementTransformer,
+  V1_GraphBuilderContext,
+  V1_GraphTransformerContext,
+  V1_PackageableElement,
+} from '@finos/legend-graph';
+import {
+  V1_buildTaggedValue,
+  V1_transformStereotype,
+  V1_transformTaggedValue,
+  PureProtocolProcessorPlugin,
+  V1_ElementBuilder,
+  V1_initPackageableElement,
+} from '@finos/legend-graph';
+
+const DATA_SPACE_ELEMENT_CLASSIFIER_PATH =
+  'meta::pure::metamodel::dataSpace::DataSpace';
+
+export class DSLDataSpace_PureProtocolProcessorPlugin extends PureProtocolProcessorPlugin {
+  constructor() {
+    super(
+      packageJson.extensions.pureProtocolProcessorPlugin,
+      packageJson.version,
+    );
+  }
+
+  install(pluginManager: GraphPluginManager): void {
+    pluginManager.registerPureProtocolProcessorPlugin(this);
+  }
+
+  override V1_getExtraElementBuilders(): V1_ElementBuilder<V1_PackageableElement>[] {
+    return [
+      new V1_ElementBuilder<V1_DataSpace>({
+        elementClassName: 'DataSpace',
+        _class: V1_DataSpace,
+        firstPass: (
+          elementProtocol: V1_PackageableElement,
+          context: V1_GraphBuilderContext,
+        ): PackageableElement => {
+          assertType(elementProtocol, V1_DataSpace);
+          const element = new DataSpace(elementProtocol.name);
+          const path = context.currentSubGraph.buildPath(
+            elementProtocol.package,
+            elementProtocol.name,
+          );
+          context.currentSubGraph.setOwnElementInExtension(
+            path,
+            element,
+            DataSpace,
+          );
+          return element;
+        },
+        secondPass: (
+          elementProtocol: V1_PackageableElement,
+          context: V1_GraphBuilderContext,
+        ): void => {
+          assertType(elementProtocol, V1_DataSpace);
+          const path = context.graph.buildPath(
+            elementProtocol.package,
+            elementProtocol.name,
+          );
+          const element = getDataSpace(path, context.graph);
+          element.stereotypes = elementProtocol.stereotypes
+            .map((stereotype) => context.resolveStereotype(stereotype))
+            .filter(isNonNullable);
+          element.taggedValues = elementProtocol.taggedValues
+            .map((taggedValue) => V1_buildTaggedValue(taggedValue, context))
+            .filter(isNonNullable);
+          element.groupId = elementProtocol.groupId;
+          element.artifactId = elementProtocol.artifactId;
+          element.versionId = elementProtocol.versionId;
+          element.mapping = elementProtocol.mapping;
+          element.runtime = elementProtocol.runtime;
+          element.description = elementProtocol.description;
+          element.supportEmail = elementProtocol.supportEmail;
+          element.diagrams = elementProtocol.diagrams ?? [];
+        },
+      }),
+    ];
+  }
+
+  override V1_getExtraElementClassifierPathGetters(): V1_ElementProtocolClassifierPathGetter[] {
+    return [
+      (elementProtocol: V1_PackageableElement): string | undefined => {
+        if (elementProtocol instanceof V1_DataSpace) {
+          return DATA_SPACE_ELEMENT_CLASSIFIER_PATH;
+        }
+        return undefined;
+      },
+    ];
+  }
+
+  override V1_getExtraElementProtocolSerializers(): V1_ElementProtocolSerializer[] {
+    return [
+      (
+        elementProtocol: V1_PackageableElement,
+      ): PlainObject<V1_PackageableElement> | undefined => {
+        if (elementProtocol instanceof V1_DataSpace) {
+          return serialize(V1_dataSpaceModelSchema, elementProtocol);
+        }
+        return undefined;
+      },
+    ];
+  }
+
+  override V1_getExtraElementProtocolDeserializers(): V1_ElementProtocolDeserializer[] {
+    return [
+      (
+        json: PlainObject<V1_PackageableElement>,
+      ): V1_PackageableElement | undefined => {
+        if (json._type === V1_DATA_SPACE_ELEMENT_PROTOCOL_TYPE) {
+          return deserialize(V1_dataSpaceModelSchema, json);
+        }
+        return undefined;
+      },
+    ];
+  }
+
+  override V1_getExtraElementTransformers(): V1_ElementTransformer[] {
+    return [
+      (
+        metamodel: PackageableElement,
+        context: V1_GraphTransformerContext,
+      ): V1_PackageableElement | undefined => {
+        if (metamodel instanceof DataSpace) {
+          const protocol = new V1_DataSpace();
+          V1_initPackageableElement(protocol, metamodel);
+          protocol.stereotypes = metamodel.stereotypes.map(
+            V1_transformStereotype,
+          );
+          protocol.taggedValues = metamodel.taggedValues.map(
+            V1_transformTaggedValue,
+          );
+          protocol.groupId = metamodel.groupId;
+          protocol.artifactId = metamodel.artifactId;
+          protocol.versionId = metamodel.versionId;
+          protocol.mapping = metamodel.mapping;
+          protocol.runtime = metamodel.runtime;
+          protocol.description = metamodel.description;
+          protocol.supportEmail = metamodel.supportEmail;
+          protocol.diagrams = metamodel.diagrams;
+          return protocol;
+        }
+        return undefined;
+      },
+    ];
+  }
+}