@finos/legend-extension-dsl-data-space 10.1.89 → 10.1.91

package/src/graph-manager/protocol/pure/DSL_DataSpace_PureProtocolProcessorPlugin.ts

@@ -20,10 +20,11 @@ import {
   V1_DataSpace,
   V1_DataSpaceDiagram,
   V1_DataSpaceElementPointer,
-  V1_DataSpaceExecutable,
   V1_DataSpaceExecutionContext,
+  V1_DataSpacePackageableElementExecutable,
   V1_DataSpaceSupportCombinedInfo,
   V1_DataSpaceSupportEmail,
+  V1_DataSpaceTemplateExecutable,
 } from './v1/model/packageableElements/dataSpace/V1_DSL_DataSpace_DataSpace.js';
 import {
   type PlainObject,
@@ -45,14 +46,15 @@ import {
 import { V1_resolveDataSpace } from './v1/transformation/pureGraph/V1_DSL_DataSpace_GraphBuilderHelper.js';
 import { getOwnDataSpace } from '../../DSL_DataSpace_GraphManagerHelper.js';
 import {
+  type DataSpaceElement,
   DataSpace,
-  DataSpaceExecutable,
   DataSpaceExecutionContext,
   DataSpaceSupportCombinedInfo,
   DataSpaceSupportEmail,
-  type DataSpaceElement,
   DataSpaceDiagram,
   DataSpaceElementPointer,
+  DataSpaceExecutableTemplate,
+  DataSpacePackageableElementExecutable,
 } from '../../../graph/metamodel/pure/model/packageableElements/dataSpace/DSL_DataSpace_DataSpace.js';
 import {
   type PackageableElement,
@@ -65,6 +67,17 @@ import {
   type V1_PackageableElement,
   type V1_PureModelContextData,
   type V1_TaggedValue,
+  type Mapping,
+  type MappingInclude,
+  type PackageableElementReference,
+  type V1_MappingInclude,
+  type DSL_Mapping_PureProtocolProcessorPlugin_Extension,
+  type V1_MappingIncludeBuilder,
+  type V1_MappingIncludeTransformer,
+  type V1_MappingIncludeProtocolSerializer,
+  type V1_MappingIncludeProtocolDeserializer,
+  type V1_MappingIncludeIdentifierBuilder,
+  type V1_RawLambda,
   V1_taggedValueModelSchema,
   PackageableElementExplicitReference,
   V1_PackageableElementPointer,
@@ -79,17 +92,9 @@ import {
   Class,
   Enumeration,
   Association,
-  type Mapping,
-  type MappingInclude,
-  type PackageableElementReference,
   Package,
-  type V1_MappingInclude,
-  type DSL_Mapping_PureProtocolProcessorPlugin_Extension,
-  type V1_MappingIncludeBuilder,
-  type V1_MappingIncludeTransformer,
-  type V1_MappingIncludeProtocolSerializer,
-  type V1_MappingIncludeProtocolDeserializer,
-  type V1_MappingIncludeIdentifierBuilder,
+  V1_RawValueSpecificationTransformer,
+  V1_buildRawLambdaWithResolvedPaths,
 } from '@finos/legend-graph';
 import { V1_resolveDiagram } from '@finos/legend-extension-dsl-diagram/graph';
 import { V1_MappingIncludeDataSpace } from './v1/model/packageableElements/mapping/V1_DSL_DataSpace_MappingIncludeDataSpace.js';
@@ -206,14 +211,41 @@ export class DSL_DataSpace_PureProtocolProcessorPlugin
           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 (
+                  executableProtocol instanceof V1_DataSpaceTemplateExecutable
+                ) {
+                  const executable = new DataSpaceExecutableTemplate();
+                  executable.title = executableProtocol.title;
+                  executable.description = executableProtocol.description;
+                  executable.query = V1_buildRawLambdaWithResolvedPaths(
+                    executableProtocol.query.parameters,
+                    executableProtocol.query.body,
+                    context,
+                  );
+                  if (executableProtocol.executionContextKey) {
+                    executable.executionContextKey =
+                      executableProtocol.executionContextKey;
+                  }
+                  return executable;
+                } else if (
+                  executableProtocol instanceof
+                  V1_DataSpacePackageableElementExecutable
+                ) {
+                  const executable =
+                    new DataSpacePackageableElementExecutable();
+                  executable.title = executableProtocol.title;
+                  executable.description = executableProtocol.description;
+                  executable.executable = context.resolveElement(
+                    executableProtocol.executable.path,
+                    false,
+                  );
+                  return executable;
+                } else {
+                  throw new UnsupportedOperationError(
+                    `Can't build data space executable`,
+                    executableProtocol,
+                  );
+                }
               },
             );
           }
@@ -353,14 +385,37 @@ export class DSL_DataSpace_PureProtocolProcessorPlugin
             return elementPointer;
           });
           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;
+            if (executable instanceof DataSpaceExecutableTemplate) {
+              const executableProtocol = new V1_DataSpaceTemplateExecutable();
+              executableProtocol.title = executable.title;
+              executableProtocol.description = executable.description;
+              if (executable.executionContextKey) {
+                executableProtocol.executionContextKey =
+                  executable.executionContextKey;
+              }
+              executableProtocol.query =
+                executable.query.accept_RawValueSpecificationVisitor(
+                  new V1_RawValueSpecificationTransformer(context),
+                ) as V1_RawLambda;
+              return executableProtocol;
+            } else if (
+              executable instanceof DataSpacePackageableElementExecutable
+            ) {
+              const executableProtocol =
+                new V1_DataSpacePackageableElementExecutable();
+              executableProtocol.title = executable.title;
+              executableProtocol.description = executable.description;
+              executableProtocol.executable = new V1_PackageableElementPointer(
+                undefined,
+                executable.executable.valueForSerialization ?? '',
+              );
+              return executableProtocol;
+            } else {
+              throw new UnsupportedOperationError(
+                `Can't transform data space executable`,
+                executable,
+              );
+            }
           });
           protocol.diagrams = metamodel.diagrams?.map((diagram) => {
             const diagramProtocol = new V1_DataSpaceDiagram();

package/src/graph-manager/protocol/pure/v1/V1_DSL_DataSpace_PureGraphManagerExtension.ts

@@ -70,6 +70,7 @@ import {
   DataSpaceAssociationDocumentationEntry,
   DataSpaceMultiExecutionServiceExecutableInfo,
   DataSpaceMultiExecutionServiceKeyedExecutableInfo,
+  DataSpaceTemplateExecutableInfo,
 } from '../../../action/analytics/DataSpaceAnalysis.js';
 import { DSL_DataSpace_PureGraphManagerExtension } from '../DSL_DataSpace_PureGraphManagerExtension.js';
 import {
@@ -81,6 +82,7 @@ import {
   V1_DataSpaceServiceExecutableInfo,
   V1_deserializeDataSpaceAnalysisResult,
   V1_DataSpaceMultiExecutionServiceExecutableInfo,
+  V1_DataSpaceTemplateExecutableInfo,
 } from './engine/analytics/V1_DataSpaceAnalysis.js';
 import { getDiagram } from '@finos/legend-extension-dsl-diagram/graph';
 
@@ -487,8 +489,17 @@ export class V1_DSL_DataSpace_PureGraphManagerExtension extends DSL_DataSpace_Pu
         const executable = new DataSpaceExecutableAnalysisResult();
         executable.title = executableProtocol.title;
         executable.description = executableProtocol.description;
-        executable.executable = executableProtocol.executable;
+        if (executableProtocol.executable) {
+          executable.executable = executableProtocol.executable;
+        }
         if (
+          executableProtocol.info instanceof V1_DataSpaceTemplateExecutableInfo
+        ) {
+          const templateExecutableInfo = new DataSpaceTemplateExecutableInfo();
+          templateExecutableInfo.query = executableProtocol.info.query;
+          templateExecutableInfo.executionContextKey =
+            executableProtocol.info.executionContextKey;
+        } else if (
           executableProtocol.info instanceof V1_DataSpaceServiceExecutableInfo
         ) {
           const serviceExecutableInfo = new DataSpaceServiceExecutableInfo();

package/src/graph-manager/protocol/pure/v1/engine/analytics/V1_DataSpaceAnalysis.ts

@@ -248,10 +248,25 @@ export abstract class V1_DataSpaceExecutableInfo {
   query!: string;
 }
 
+const V1_DATA_SPACE_TEMPLATE_EXECUTABLE_INFO_TYPE = 'templateExecutableInfo';
 const V1_DATA_SPACE_SERVICE_EXECUTABLE_INFO_TYPE = 'service';
 const V1_DATA_SPACE_MULTI_EXECUTION_SERVICE_EXECUTABLE_INFO_TYPE =
   'multiExecutionService';
 
+export class V1_DataSpaceTemplateExecutableInfo extends V1_DataSpaceExecutableInfo {
+  executionContextKey!: string;
+}
+
+const V1_DataSpaceTemplateExecutableInfoModelSchema = (
+  plugins: PureProtocolProcessorPlugin[],
+): ModelSchema<V1_DataSpaceTemplateExecutableInfo> =>
+  createModelSchema(V1_DataSpaceTemplateExecutableInfo, {
+    _type: usingConstantValueSchema(
+      V1_DATA_SPACE_TEMPLATE_EXECUTABLE_INFO_TYPE,
+    ),
+    executionContextKey: primitive(),
+  });
+
 export class V1_DataSpaceServiceExecutableInfo extends V1_DataSpaceExecutableInfo {
   pattern!: string;
   mapping?: string | undefined;
@@ -328,6 +343,11 @@ const V1_deserializeDataSpaceExecutableInfo = (
   json: PlainObject<V1_DataSpaceExecutableInfo>,
 ): V1_DataSpaceExecutableInfo => {
   switch (json._type) {
+    case V1_DATA_SPACE_TEMPLATE_EXECUTABLE_INFO_TYPE:
+      return deserialize(
+        V1_DataSpaceTemplateExecutableInfoModelSchema(plugins),
+        json,
+      );
     case V1_DATA_SPACE_SERVICE_EXECUTABLE_INFO_TYPE:
       return deserialize(
         V1_dataSpaceServiceExecutableInfoModelSchema(plugins),
@@ -399,7 +419,7 @@ const V1_deserializeDataSpaceExecutableResult = (
 export class V1_DataSpaceExecutableAnalysisResult {
   title!: string;
   description?: string | undefined;
-  executable!: string;
+  executable?: string;
   info?: V1_DataSpaceExecutableInfo | undefined;
   result!: V1_DataSpaceExecutableResult;
 }
@@ -408,7 +428,7 @@ const V1_dataSpaceExecutableAnalysisResultModelSchema = (
   plugins: PureProtocolProcessorPlugin[],
 ): ModelSchema<V1_DataSpaceExecutableAnalysisResult> =>
   createModelSchema(V1_DataSpaceExecutableAnalysisResult, {
-    executable: primitive(),
+    executable: optional(primitive()),
     description: optional(primitive()),
     info: optionalCustom(
       () => SKIP,

package/src/graph-manager/protocol/pure/v1/model/packageableElements/dataSpace/V1_DSL_DataSpace_DataSpace.ts

@@ -17,11 +17,12 @@
 import { hashArray, type Hashable } from '@finos/legend-shared';
 import { DATA_SPACE_HASH_STRUCTURE } from '../../../../../../../graph/DSL_DataSpace_HashUtils.js';
 import {
-  V1_PackageableElement,
+  type V1_RawLambda,
   type V1_PackageableElementPointer,
   type V1_PackageableElementVisitor,
   type V1_StereotypePtr,
   type V1_TaggedValue,
+  V1_PackageableElement,
 } from '@finos/legend-graph';
 
 export class V1_DataSpaceExecutionContext implements Hashable {
@@ -56,21 +57,53 @@ export class V1_DataSpaceElementPointer implements Hashable {
   }
 }
 
-export class V1_DataSpaceExecutable implements Hashable {
+export abstract 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 ?? '',
+    ]);
+  }
+}
+
+export class V1_DataSpacePackageableElementExecutable
+  extends V1_DataSpaceExecutable
+  implements Hashable
+{
+  executable!: V1_PackageableElementPointer;
+
+  override get hashCode(): string {
+    return hashArray([
+      DATA_SPACE_HASH_STRUCTURE.DATA_SPACE_PACKAGEABLE_ELEMENT_EXECUTABLE,
+      this.title,
+      this.description ?? '',
       this.executable.path,
     ]);
   }
 }
 
+export class V1_DataSpaceTemplateExecutable
+  extends V1_DataSpaceExecutable
+  implements Hashable
+{
+  query!: V1_RawLambda;
+  executionContextKey?: string;
+
+  override get hashCode(): string {
+    return hashArray([
+      DATA_SPACE_HASH_STRUCTURE.DATA_SPACE_TEMPLATE_EXECUTABLE,
+      this.title,
+      this.description ?? '',
+      this.query,
+      this.executionContextKey ?? '',
+    ]);
+  }
+}
+
 export class V1_DataSpaceDiagram implements Hashable {
   title!: string;
   description?: string | undefined;

package/src/graph-manager/protocol/pure/v1/transformation/pureProtocol/V1_DSL_DataSpace_ProtocolHelper.ts

@@ -30,6 +30,7 @@ import {
   V1_taggedValueModelSchema,
   V1_packageableElementPointerModelSchema,
   V1_PackageableElementPointer,
+  V1_rawLambdaModelSchema,
 } from '@finos/legend-graph';
 import {
   type PlainObject,
@@ -43,19 +44,24 @@ import {
 } from '@finos/legend-shared';
 import {
   type V1_DataSpaceSupportInfo,
+  type V1_DataSpaceExecutable,
   V1_DataSpace,
   V1_DataSpaceExecutionContext,
   V1_DataSpaceSupportEmail,
   V1_DataSpaceSupportCombinedInfo,
-  V1_DataSpaceExecutable,
   V1_DataSpaceDiagram,
   V1_DataSpaceElementPointer,
+  V1_DataSpaceTemplateExecutable,
+  V1_DataSpacePackageableElementExecutable,
 } from '../../model/packageableElements/dataSpace/V1_DSL_DataSpace_DataSpace.js';
 import { V1_MappingIncludeDataSpace } from '../../model/packageableElements/mapping/V1_DSL_DataSpace_MappingIncludeDataSpace.js';
 
 export const V1_DATA_SPACE_ELEMENT_PROTOCOL_TYPE = 'dataSpace';
 const V1_DATA_SPACE_SUPPORT_EMAIL_TYPE = 'email';
 const V1_DATA_SPACE_SUPPORT_COMBINED_INFO_TYPE = 'combined';
+const V1_DATA_SPACE_PACKAGEABLE_ELEMENT_EXECUTABLE =
+  'dataSpacePackageableElementExecutable';
+const V1_DATA_SPACE_TEMPLATE_EXECUTABLE = 'dataSpaceTemplateExecutable';
 
 const V1_dataSpaceExecutionContextModelSchema = createModelSchema(
   V1_DataSpaceExecutionContext,
@@ -130,18 +136,61 @@ const V1_dataSpaceElementPointerModelSchema = createModelSchema(
   },
 );
 
-const V1_PACKAGEABLEELEMENT_EXECUTABLE =
-  'dataSpacePackageableElementExecutable';
-const V1_dataSpaceExecutableModelSchema = createModelSchema(
-  V1_DataSpaceExecutable,
+const V1_dataSpacePackageableElementExecutableModelSchema = createModelSchema(
+  V1_DataSpacePackageableElementExecutable,
   {
-    _type: usingConstantValueSchema(V1_PACKAGEABLEELEMENT_EXECUTABLE),
+    _type: usingConstantValueSchema(
+      V1_DATA_SPACE_PACKAGEABLE_ELEMENT_EXECUTABLE,
+    ),
     description: optional(primitive()),
+    title: primitive(),
     executable: usingModelSchema(V1_packageableElementPointerModelSchema),
+  },
+);
+
+const V1_dataSpaceTemplateExecutableModelSchema = createModelSchema(
+  V1_DataSpaceTemplateExecutable,
+  {
+    _type: usingConstantValueSchema(V1_DATA_SPACE_TEMPLATE_EXECUTABLE),
+    description: optional(primitive()),
     title: primitive(),
+    query: usingModelSchema(V1_rawLambdaModelSchema),
+    executionContextKey: optional(primitive()),
   },
 );
 
+const V1_serializeDataspaceExecutable = (
+  protocol: V1_DataSpaceExecutable,
+): PlainObject<V1_DataSpaceExecutable> => {
+  if (protocol instanceof V1_DataSpaceTemplateExecutable) {
+    return serialize(V1_dataSpaceTemplateExecutableModelSchema, protocol);
+  } else if (protocol instanceof V1_DataSpacePackageableElementExecutable) {
+    return serialize(
+      V1_dataSpacePackageableElementExecutableModelSchema,
+      protocol,
+    );
+  }
+  throw new UnsupportedOperationError(
+    `Can't serialize data space executable`,
+    protocol,
+  );
+};
+
+export const V1_deserializeDataspaceExecutable = (
+  json: PlainObject<V1_DataSpaceExecutable>,
+): V1_DataSpaceSupportInfo => {
+  switch (json._type) {
+    case V1_DATA_SPACE_TEMPLATE_EXECUTABLE:
+      return deserialize(V1_dataSpaceTemplateExecutableModelSchema, json);
+    case V1_DATA_SPACE_PACKAGEABLE_ELEMENT_EXECUTABLE:
+    default:
+      return deserialize(
+        V1_dataSpacePackageableElementExecutableModelSchema,
+        json,
+      );
+  }
+};
+
 const V1_dataSpaceDiagramModelSchema = createModelSchema(V1_DataSpaceDiagram, {
   description: optional(primitive()),
   diagram: usingModelSchema(V1_packageableElementPointerModelSchema),
@@ -154,7 +203,12 @@ const V1_dataSpaceModelSchema = createModelSchema(V1_DataSpace, {
   description: optional(primitive()),
   diagrams: list(object(V1_dataSpaceDiagramModelSchema)),
   elements: optionalCustomListWithSchema(V1_dataSpaceElementPointerModelSchema),
-  executables: list(object(V1_dataSpaceExecutableModelSchema)),
+  executables: list(
+    custom(
+      (val) => V1_serializeDataspaceExecutable(val),
+      (val) => V1_deserializeDataspaceExecutable(val),
+    ),
+  ),
   executionContexts: list(object(V1_dataSpaceExecutionContextModelSchema)),
   featuredDiagrams: optionalCustomListWithSchema(
     V1_packageableElementPointerModelSchema,