@finos/legend-extension-dsl-data-space 9.1.4 → 9.1.6

package/src/graphManager/protocol/pure/DSL_DataSpace_PureProtocolProcessorPlugin.ts

@@ -18,7 +18,10 @@ import packageJson from '../../../../package.json';
 import V1_SYSTEM_MODELS from './v1/V1_DSL_DataSpace_SystemModels.json';
 import {
   V1_DataSpace,
+  V1_DataSpaceDiagram,
+  V1_DataSpaceExecutable,
   V1_DataSpaceExecutionContext,
+  V1_DataSpaceSupportCombinedInfo,
   V1_DataSpaceSupportEmail,
 } from './v1/model/packageableElements/dataSpace/V1_DSL_DataSpace_DataSpace.js';
 import {
@@ -37,8 +40,12 @@ import {
 import { getOwnDataSpace } from '../../DSL_DataSpace_GraphManagerHelper.js';
 import {
   DataSpace,
+  DataSpaceExecutable,
   DataSpaceExecutionContext,
+  DataSpaceSupportCombinedInfo,
   DataSpaceSupportEmail,
+  type DataSpaceElement,
+  DataSpaceDiagram,
 } from '../../../graph/metamodel/pure/model/packageableElements/dataSpace/DSL_DataSpace_DataSpace.js';
 import {
   type PackageableElement,
@@ -65,10 +72,11 @@ import {
   Class,
   Enumeration,
   Association,
+  type PackageableElementReference,
 } from '@finos/legend-graph';
 import {
   V1_DSL_Diagram_PackageableElementPointerType,
-  getDiagram,
+  V1_resolveDiagram,
 } from '@finos/legend-extension-dsl-diagram';
 
 export const DATA_SPACE_ELEMENT_CLASSIFIER_PATH =
@@ -129,6 +137,7 @@ export class DSL_DataSpace_PureProtocolProcessorPlugin extends PureProtocolProce
               contextProtocol.name,
               `Data space execution context 'name' field is missing or empty`,
             );
+            execContext.title = contextProtocol.title;
             execContext.description = contextProtocol.description;
             execContext.mapping = PackageableElementExplicitReference.create(
               context.graph.getMapping(contextProtocol.mapping.path),
@@ -154,37 +163,79 @@ export class DSL_DataSpace_PureProtocolProcessorPlugin extends PureProtocolProce
           element.description = elementProtocol.description;
           if (elementProtocol.featuredDiagrams) {
             element.featuredDiagrams = elementProtocol.featuredDiagrams.map(
-              (pointer) =>
-                PackageableElementExplicitReference.create(
-                  getDiagram(pointer.path, context.graph),
-                ),
+              (pointer) => V1_resolveDiagram(pointer.path, context),
             );
           }
           if (elementProtocol.elements) {
             element.elements = elementProtocol.elements.map((pointer) => {
-              const el = context.graph.getElement(pointer.path);
+              const elementReference = context.resolveElement(
+                pointer.path,
+                false,
+              );
               if (
-                el instanceof Class ||
-                el instanceof Enumeration ||
-                el instanceof Association
+                elementReference.value instanceof Class ||
+                elementReference.value instanceof Enumeration ||
+                elementReference.value instanceof Association
               ) {
-                return PackageableElementExplicitReference.create(el);
+                return elementReference as unknown as PackageableElementReference<DataSpaceElement>;
               }
               throw new UnsupportedOperationError(
                 `Can't find data space element (only allow class, enumartion, association) '${pointer.path}'`,
               );
             });
           }
+          if (elementProtocol.executables) {
+            element.executables = elementProtocol.executables.map(
+              (executableProtocol) => {
+                const executable = new DataSpaceExecutable();
+                executable.title = executableProtocol.title;
+                executable.description = executableProtocol.description;
+                executable.executable = context.resolveElement(
+                  executableProtocol.executable.path,
+                  false,
+                );
+                return executable;
+              },
+            );
+          }
+          if (elementProtocol.diagrams) {
+            element.diagrams = elementProtocol.diagrams.map(
+              (diagramProtocol) => {
+                const diagram = new DataSpaceDiagram();
+                diagram.title = diagramProtocol.title;
+                diagram.description = diagramProtocol.description;
+                diagram.diagram = V1_resolveDiagram(
+                  diagramProtocol.diagram.path,
+                  context,
+                );
+                return diagram;
+              },
+            );
+          }
           if (elementProtocol.supportInfo) {
             if (
               elementProtocol.supportInfo instanceof V1_DataSpaceSupportEmail
             ) {
               const supportEmail = new DataSpaceSupportEmail();
+              supportEmail.documentationUrl =
+                elementProtocol.supportInfo.documentationUrl;
               supportEmail.address = guaranteeNonEmptyString(
                 elementProtocol.supportInfo.address,
                 `Data space support email 'address' field is missing or empty`,
               );
               element.supportInfo = supportEmail;
+            } else if (
+              elementProtocol.supportInfo instanceof
+              V1_DataSpaceSupportCombinedInfo
+            ) {
+              const combinedInfo = new DataSpaceSupportCombinedInfo();
+              combinedInfo.documentationUrl =
+                elementProtocol.supportInfo.documentationUrl;
+              combinedInfo.emails = elementProtocol.supportInfo.emails;
+              combinedInfo.website = elementProtocol.supportInfo.website;
+              combinedInfo.faqUrl = elementProtocol.supportInfo.faqUrl;
+              combinedInfo.supportUrl = elementProtocol.supportInfo.supportUrl;
+              element.supportInfo = combinedInfo;
             } else {
               throw new UnsupportedOperationError(
                 `Can't build data space support info`,
@@ -259,6 +310,7 @@ export class DSL_DataSpace_PureProtocolProcessorPlugin extends PureProtocolProce
             (execContext) => {
               const contextProtocol = new V1_DataSpaceExecutionContext();
               contextProtocol.name = execContext.name;
+              contextProtocol.title = execContext.title;
               contextProtocol.description = execContext.description;
               contextProtocol.mapping = new V1_PackageableElementPointer(
                 PackageableElementPointerType.MAPPING,
@@ -276,24 +328,57 @@ export class DSL_DataSpace_PureProtocolProcessorPlugin extends PureProtocolProce
           protocol.title = metamodel.title;
           protocol.description = metamodel.description;
           protocol.featuredDiagrams = metamodel.featuredDiagrams?.map(
-            (diagramPath) =>
+            (diagramReference) =>
               new V1_PackageableElementPointer(
                 V1_DSL_Diagram_PackageableElementPointerType,
-                diagramPath.valueForSerialization ?? '',
+                diagramReference.valueForSerialization ?? '',
               ),
           );
           protocol.elements = metamodel.elements?.map(
-            (elPath) =>
+            (elementReference) =>
               new V1_PackageableElementPointer(
                 PackageableElementPointerType.CLASS,
-                elPath.valueForSerialization ?? '',
+                elementReference.valueForSerialization ?? '',
               ),
           );
+          protocol.executables = metamodel.executables?.map((executable) => {
+            const executableProtocol = new V1_DataSpaceExecutable();
+            executableProtocol.title = executable.title;
+            executableProtocol.description = executable.description;
+            executableProtocol.executable = new V1_PackageableElementPointer(
+              undefined,
+              executable.executable.valueForSerialization ?? '',
+            );
+            return executableProtocol;
+          });
+          protocol.diagrams = metamodel.diagrams?.map((diagram) => {
+            const diagramProtocol = new V1_DataSpaceDiagram();
+            diagramProtocol.title = diagram.title;
+            diagramProtocol.description = diagram.description;
+            diagramProtocol.diagram = new V1_PackageableElementPointer(
+              undefined,
+              diagram.diagram.valueForSerialization ?? '',
+            );
+            return diagramProtocol;
+          });
           if (metamodel.supportInfo) {
             if (metamodel.supportInfo instanceof DataSpaceSupportEmail) {
               const supportEmail = new V1_DataSpaceSupportEmail();
+              supportEmail.documentationUrl =
+                metamodel.supportInfo.documentationUrl;
               supportEmail.address = metamodel.supportInfo.address;
               protocol.supportInfo = supportEmail;
+            } else if (
+              metamodel.supportInfo instanceof DataSpaceSupportCombinedInfo
+            ) {
+              const combinedInfo = new V1_DataSpaceSupportCombinedInfo();
+              combinedInfo.documentationUrl =
+                metamodel.supportInfo.documentationUrl;
+              combinedInfo.emails = metamodel.supportInfo.emails;
+              combinedInfo.website = metamodel.supportInfo.website;
+              combinedInfo.faqUrl = metamodel.supportInfo.faqUrl;
+              combinedInfo.supportUrl = metamodel.supportInfo.supportUrl;
+              protocol.supportInfo = combinedInfo;
             } else {
               throw new UnsupportedOperationError(
                 `Can't transform data space support info`,

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

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-import { getDiagram } from '@finos/legend-extension-dsl-diagram';
 import {
   PureModel,
   V1_PureGraphManager,
@@ -42,12 +41,23 @@ import {
   uniq,
   type PlainObject,
 } from '@finos/legend-shared';
-import { DataSpaceSupportEmail } from '../../../../graph/metamodel/pure/model/packageableElements/dataSpace/DSL_DataSpace_DataSpace.js';
-import { V1_DataSpaceSupportEmail } from '../../../../graphManager/protocol/pure/v1/model/packageableElements/dataSpace/V1_DSL_DataSpace_DataSpace.js';
+import {
+  DataSpaceSupportCombinedInfo,
+  DataSpaceSupportEmail,
+} from '../../../../graph/metamodel/pure/model/packageableElements/dataSpace/DSL_DataSpace_DataSpace.js';
+import {
+  V1_DataSpaceSupportCombinedInfo,
+  V1_DataSpaceSupportEmail,
+} from '../../../../graphManager/protocol/pure/v1/model/packageableElements/dataSpace/V1_DSL_DataSpace_DataSpace.js';
 import {
   DataSpaceAnalysisResult,
+  DataSpaceDiagramAnalysisResult,
   DataSpaceDocumentationEntry,
+  DataSpaceExecutableAnalysisResult,
+  DataSpaceExecutableTDSResultColumn,
+  DataSpaceExecutableTDSResult,
   DataSpaceExecutionContextAnalysisResult,
+  DataSpaceServiceExecutableInfo,
   DataSpaceStereotypeInfo,
   DataSpaceTaggedValueInfo,
 } from '../../../action/analytics/DataSpaceAnalysis.js';
@@ -57,7 +67,10 @@ import {
   V1_DataSpaceAssociationDocumentationEntry,
   V1_DataSpaceClassDocumentationEntry,
   V1_DataSpaceEnumerationDocumentationEntry,
+  V1_DataSpaceExecutableTDSResult,
+  V1_DataSpaceServiceExecutableInfo,
 } from './engine/analytics/V1_DataSpaceAnalysis.js';
+import { getDiagram } from '@finos/legend-extension-dsl-diagram';
 
 const ANALYZE_DATA_SPACE_TRACE = 'analyze data space';
 
@@ -153,11 +166,24 @@ export class V1_DSL_DataSpace_PureGraphManagerExtension extends DSL_DataSpace_Pu
     if (analysisResult.supportInfo) {
       if (analysisResult.supportInfo instanceof V1_DataSpaceSupportEmail) {
         const supportEmail = new DataSpaceSupportEmail();
+        supportEmail.documentationUrl =
+          analysisResult.supportInfo.documentationUrl;
         supportEmail.address = guaranteeNonEmptyString(
           analysisResult.supportInfo.address,
           `Data space support email 'address' field is missing or empty`,
         );
         result.supportInfo = supportEmail;
+      } else if (
+        analysisResult.supportInfo instanceof V1_DataSpaceSupportCombinedInfo
+      ) {
+        const combinedInfo = new DataSpaceSupportCombinedInfo();
+        combinedInfo.documentationUrl =
+          analysisResult.supportInfo.documentationUrl;
+        combinedInfo.website = analysisResult.supportInfo.website;
+        combinedInfo.faqUrl = analysisResult.supportInfo.faqUrl;
+        combinedInfo.supportUrl = analysisResult.supportInfo.supportUrl;
+        combinedInfo.emails = analysisResult.supportInfo.emails;
+        result.supportInfo = combinedInfo;
       }
       // NOTE: we will relax the check and not throw here for unknown support info type
     }
@@ -269,6 +295,7 @@ export class V1_DSL_DataSpace_PureGraphManagerExtension extends DSL_DataSpace_Pu
       const contextAnalysisResult =
         new DataSpaceExecutionContextAnalysisResult();
       contextAnalysisResult.name = context.name;
+      contextAnalysisResult.title = context.title;
       contextAnalysisResult.description = context.description;
       contextAnalysisResult.mapping = graph.getMapping(context.mapping);
       contextAnalysisResult.defaultRuntime = graph.getRuntime(
@@ -286,11 +313,6 @@ export class V1_DSL_DataSpace_PureGraphManagerExtension extends DSL_DataSpace_Pu
       result.executionContextsIndex.get(analysisResult.defaultExecutionContext),
     );
 
-    // featured diagrams
-    result.featuredDiagrams = analysisResult.featuredDiagrams.map((path) =>
-      getDiagram(path, graph),
-    );
-
     // elements documentation
     result.elementDocs = analysisResult.elementDocs.flatMap((docEntry) => {
       const entries: DataSpaceDocumentationEntry[] = [];
@@ -311,15 +333,7 @@ export class V1_DSL_DataSpace_PureGraphManagerExtension extends DSL_DataSpace_Pu
             ),
           );
         });
-        docEntry.inheritedProperties.forEach((property) => {
-          entries.push(
-            new DataSpaceDocumentationEntry(
-              docEntry.path,
-              property.name,
-              property.docs.join('\n'),
-            ),
-          );
-        });
+        // NOTE: we don't want to list inherited properties
       } else if (
         docEntry instanceof V1_DataSpaceEnumerationDocumentationEntry
       ) {
@@ -348,6 +362,61 @@ export class V1_DSL_DataSpace_PureGraphManagerExtension extends DSL_DataSpace_Pu
       return entries;
     });
 
+    // featured diagrams
+    result.diagrams = analysisResult.featuredDiagrams
+      .map((path) => {
+        const diagram = new DataSpaceDiagramAnalysisResult();
+        diagram.title = path;
+        diagram.diagram = getDiagram(path, graph);
+        return diagram;
+      })
+      .concat(
+        analysisResult.diagrams.map((diagramProtocol) => {
+          const diagram = new DataSpaceDiagramAnalysisResult();
+          diagram.title = diagramProtocol.title;
+          diagram.description = diagramProtocol.description;
+          diagram.diagram = getDiagram(diagramProtocol.diagram, graph);
+          return diagram;
+        }),
+      );
+
+    // executables
+    result.executables = analysisResult.executables.map(
+      (executableProtocol) => {
+        const executable = new DataSpaceExecutableAnalysisResult();
+        executable.title = executableProtocol.title;
+        executable.description = executableProtocol.description;
+        executable.executable = executableProtocol.executable;
+        if (
+          executableProtocol.info instanceof V1_DataSpaceServiceExecutableInfo
+        ) {
+          const serviceExecutableInfo = new DataSpaceServiceExecutableInfo();
+          serviceExecutableInfo.query = executableProtocol.info.query;
+          serviceExecutableInfo.pattern = executableProtocol.info.pattern;
+          serviceExecutableInfo.mapping = executableProtocol.info.mapping;
+          serviceExecutableInfo.runtime = executableProtocol.info.runtime;
+          executable.info = serviceExecutableInfo;
+        }
+        if (
+          executableProtocol.result instanceof V1_DataSpaceExecutableTDSResult
+        ) {
+          const tdsResult = new DataSpaceExecutableTDSResult();
+          tdsResult.columns = executableProtocol.result.columns.map(
+            (tdsColumn) => {
+              const column = new DataSpaceExecutableTDSResultColumn();
+              column.name = tdsColumn.name;
+              column.type = tdsColumn.type;
+              column.relationalType = tdsColumn.relationalType;
+              column.documentation = tdsColumn.documentation;
+              return column;
+            },
+          );
+          executable.result = tdsResult;
+        }
+        return executable;
+      },
+    );
+
     return result;
   }
 }

package/src/graphManager/protocol/pure/v1/V1_DSL_DataSpace_SystemModels.json

@@ -5,6 +5,13 @@
       "_type": "profile",
       "name": "enterprise",
       "tags": ["taxonomyNodes"]
+    },
+    {
+      "_type": "profile",
+      "name": "DataSpaceInfo",
+      "package": "meta::pure::metamodel::dataSpace::profiles",
+      "stereotypes": ["Verified"],
+      "tags": ["deprecationNotice"]
     }
   ]
 }

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

@@ -20,10 +20,13 @@ import {
   optionalCustom,
   type PlainObject,
   UnsupportedOperationError,
+  customListWithSchema,
+  usingConstantValueSchema,
 } from '@finos/legend-shared';
 import {
   createModelSchema,
   custom,
+  deserialize,
   list,
   object,
   optional,
@@ -61,6 +64,7 @@ class V1_DataSpaceStereotypeInfo {
 
 class V1_DataSpaceExecutionContextAnalysisResult {
   name!: string;
+  title?: string | undefined;
   description?: string | undefined;
   mapping!: string;
   defaultRuntime!: string;
@@ -73,6 +77,7 @@ class V1_DataSpaceExecutionContextAnalysisResult {
       mapping: primitive(),
       defaultRuntime: primitive(),
       compatibleRuntimes: list(primitive()),
+      title: optional(primitive()),
     }),
   );
 }
@@ -172,6 +177,129 @@ function V1_deserializeModelDocumentationEntry(
   }
 }
 
+export class V1_DataSpaceDiagramAnalysisResult {
+  title!: string;
+  description?: string | undefined;
+  diagram!: string;
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(V1_DataSpaceDiagramAnalysisResult, {
+      description: optional(primitive()),
+      diagram: primitive(),
+      title: primitive(),
+    }),
+  );
+}
+
+export abstract class V1_DataSpaceExecutableInfo {
+  query!: string;
+}
+
+const V1_DATA_SPACE_SERVICE_EXECUTABLE_INFO_TYPE = 'service';
+
+export class V1_DataSpaceServiceExecutableInfo extends V1_DataSpaceExecutableInfo {
+  pattern!: string;
+  mapping?: string | undefined;
+  runtime?: string | undefined;
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(V1_DataSpaceServiceExecutableInfo, {
+      _type: usingConstantValueSchema(
+        V1_DATA_SPACE_SERVICE_EXECUTABLE_INFO_TYPE,
+      ),
+      mapping: optional(primitive()),
+      pattern: primitive(),
+      query: primitive(),
+      runtime: optional(primitive()),
+    }),
+  );
+}
+
+const V1_deserializeDataSpaceExecutableInfo = (
+  json: PlainObject<V1_DataSpaceExecutableInfo>,
+): V1_DataSpaceExecutableInfo => {
+  switch (json._type) {
+    case V1_DATA_SPACE_SERVICE_EXECUTABLE_INFO_TYPE:
+      return deserialize(
+        V1_DataSpaceServiceExecutableInfo.serialization.schema,
+        json,
+      );
+    default:
+      throw new UnsupportedOperationError(
+        `Can't deserialize data space executable info of type '${json._type}'`,
+      );
+  }
+};
+
+export abstract class V1_DataSpaceExecutableResult {}
+
+const V1_DATA_SPACE_EXECUTABLE_TDS_RESULT_TYPE = 'tds';
+
+export class V1_DataSpaceExecutableTDSResultColumn {
+  name!: string;
+  documentation?: string | undefined;
+  type?: string | undefined;
+  relationalType?: string | undefined;
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(V1_DataSpaceExecutableTDSResultColumn, {
+      documentation: optional(primitive()),
+      name: primitive(),
+      relationalType: optional(primitive()),
+      type: optional(primitive()),
+    }),
+  );
+}
+
+export class V1_DataSpaceExecutableTDSResult extends V1_DataSpaceExecutableResult {
+  columns: V1_DataSpaceExecutableTDSResultColumn[] = [];
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(V1_DataSpaceExecutableTDSResult, {
+      _type: usingConstantValueSchema(
+        V1_DATA_SPACE_SERVICE_EXECUTABLE_INFO_TYPE,
+      ),
+      columns: list(
+        object(V1_DataSpaceExecutableTDSResultColumn.serialization.schema),
+      ),
+    }),
+  );
+}
+
+const V1_deserializeDataSpaceExecutableResult = (
+  json: PlainObject<V1_DataSpaceExecutableResult>,
+): V1_DataSpaceExecutableResult => {
+  switch (json._type) {
+    case V1_DATA_SPACE_EXECUTABLE_TDS_RESULT_TYPE:
+      return deserialize(
+        V1_DataSpaceExecutableTDSResult.serialization.schema,
+        json,
+      );
+    default:
+      throw new UnsupportedOperationError(
+        `Can't deserialize data space executable result of type '${json._type}'`,
+      );
+  }
+};
+
+export class V1_DataSpaceExecutableAnalysisResult {
+  title!: string;
+  description?: string | undefined;
+  executable!: string;
+  info?: V1_DataSpaceExecutableInfo | undefined;
+  result!: V1_DataSpaceExecutableResult;
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(V1_DataSpaceExecutableAnalysisResult, {
+      executable: primitive(),
+      description: optional(primitive()),
+      info: optionalCustom(() => SKIP, V1_deserializeDataSpaceExecutableInfo),
+      result: custom(() => SKIP, V1_deserializeDataSpaceExecutableResult),
+      title: primitive(),
+    }),
+  );
+}
+
 export class V1_DataSpaceAnalysisResult {
   name!: string;
   package!: string;
@@ -194,6 +322,9 @@ export class V1_DataSpaceAnalysisResult {
   elements: string[] = [];
   elementDocs: V1_DataSpaceModelDocumentationEntry[] = [];
 
+  executables: V1_DataSpaceExecutableAnalysisResult[] = [];
+  diagrams: V1_DataSpaceDiagramAnalysisResult[] = [];
+
   static readonly serialization = new SerializationFactory(
     createModelSchema(V1_DataSpaceAnalysisResult, {
       name: primitive(),
@@ -205,6 +336,7 @@ export class V1_DataSpaceAnalysisResult {
 
       title: optional(primitive()),
       description: optional(primitive()),
+
       supportInfo: optionalCustom(
         () => SKIP,
         (val) => V1_deserializeSupportInfo(val),
@@ -217,12 +349,18 @@ export class V1_DataSpaceAnalysisResult {
       ),
       defaultExecutionContext: primitive(),
 
-      featuredDiagrams: list(primitive()),
-
       elements: list(primitive()),
       elementDocs: list(
         custom(() => SKIP, V1_deserializeModelDocumentationEntry),
       ),
+
+      featuredDiagrams: list(primitive()),
+      diagrams: customListWithSchema(
+        V1_DataSpaceDiagramAnalysisResult.serialization.schema,
+      ),
+      executables: customListWithSchema(
+        V1_DataSpaceExecutableAnalysisResult.serialization.schema,
+      ),
     }),
   );
 }

package/src/graphManager/protocol/pure/v1/model/packageableElements/dataSpace/V1_DSL_DataSpace_DataSpace.ts

@@ -25,6 +25,8 @@ import {
 } from '@finos/legend-graph';
 
 export abstract class V1_DataSpaceSupportInfo implements Hashable {
+  documentationUrl?: string | undefined;
+
   abstract get hashCode(): string;
 }
 
@@ -37,13 +39,36 @@ export class V1_DataSpaceSupportEmail
   get hashCode(): string {
     return hashArray([
       DATA_SPACE_HASH_STRUCTURE.DATA_SPACE_SUPPORT_EMAIL,
+      this.documentationUrl ?? '',
       this.address,
     ]);
   }
 }
 
+export class V1_DataSpaceSupportCombinedInfo
+  extends V1_DataSpaceSupportInfo
+  implements Hashable
+{
+  emails?: string[] | undefined;
+  website?: string | undefined;
+  faqUrl?: string | undefined;
+  supportUrl?: string | undefined;
+
+  get hashCode(): string {
+    return hashArray([
+      DATA_SPACE_HASH_STRUCTURE.DATA_SPACE_SUPPORT_COMBINED_INFO,
+      this.documentationUrl ?? '',
+      hashArray(this.emails ?? []),
+      this.website ?? '',
+      this.faqUrl ?? '',
+      this.supportUrl ?? '',
+    ]);
+  }
+}
+
 export class V1_DataSpaceExecutionContext implements Hashable {
   name!: string;
+  title?: string | undefined;
   description?: string | undefined;
   mapping!: V1_PackageableElementPointer;
   defaultRuntime!: V1_PackageableElementPointer;
@@ -52,6 +77,7 @@ export class V1_DataSpaceExecutionContext implements Hashable {
     return hashArray([
       DATA_SPACE_HASH_STRUCTURE.DATA_SPACE_EXECUTION_CONTEXT,
       this.name,
+      this.title ?? '',
       this.description ?? '',
       this.mapping.path,
       this.defaultRuntime.path,
@@ -59,6 +85,36 @@ export class V1_DataSpaceExecutionContext implements Hashable {
   }
 }
 
+export class V1_DataSpaceExecutable implements Hashable {
+  title!: string;
+  description?: string | undefined;
+  executable!: V1_PackageableElementPointer;
+
+  get hashCode(): string {
+    return hashArray([
+      DATA_SPACE_HASH_STRUCTURE.DATA_SPACE_EXECUTABLE,
+      this.title,
+      this.description ?? '',
+      this.executable.path,
+    ]);
+  }
+}
+
+export class V1_DataSpaceDiagram implements Hashable {
+  title!: string;
+  description?: string | undefined;
+  diagram!: V1_PackageableElementPointer;
+
+  get hashCode(): string {
+    return hashArray([
+      DATA_SPACE_HASH_STRUCTURE.DATA_SPACE_DIAGRAM,
+      this.title,
+      this.description ?? '',
+      this.diagram.path,
+    ]);
+  }
+}
+
 export class V1_DataSpace extends V1_PackageableElement implements Hashable {
   stereotypes: V1_StereotypePtr[] = [];
   taggedValues: V1_TaggedValue[] = [];
@@ -68,6 +124,8 @@ export class V1_DataSpace extends V1_PackageableElement implements Hashable {
   defaultExecutionContext!: string;
   featuredDiagrams?: V1_PackageableElementPointer[] | undefined;
   elements?: V1_PackageableElementPointer[] | undefined;
+  executables?: V1_DataSpaceExecutable[] | undefined;
+  diagrams?: V1_DataSpaceDiagram[] | undefined;
   supportInfo?: V1_DataSpaceSupportInfo | undefined;
 
   override get hashCode(): string {
@@ -81,6 +139,8 @@ export class V1_DataSpace extends V1_PackageableElement implements Hashable {
       this.defaultExecutionContext,
       hashArray((this.featuredDiagrams ?? []).map((pointer) => pointer.path)),
       hashArray((this.elements ?? []).map((pointer) => pointer.path)),
+      hashArray(this.executables ?? []),
+      hashArray(this.diagrams ?? []),
       this.supportInfo ?? '',
     ]);
   }