@finos/legend-graph 0.0.6 → 0.1.3

package/src/models/protocols/pure/v1/transformation/pureGraph/to/helpers/V1_DomainBuilderHelper.ts

@@ -49,7 +49,7 @@ export const V1_buildTaggedValue = (
   taggedValue: V1_TaggedValue,
   context: V1_GraphBuilderContext,
 ): TaggedValue | undefined => {
-  assertNonNullable(taggedValue.tag, 'Tagged value tag pointer is missing');
+  assertNonNullable(taggedValue.tag, `Tagged value 'tag' field is missing`);
   return new TaggedValue(
     context.resolveTag(taggedValue.tag),
     taggedValue.value,
@@ -61,10 +61,13 @@ export const V1_buildConstraint = (
   _class: Class,
   context: V1_GraphBuilderContext,
 ): Constraint => {
-  assertNonEmptyString(constraint.name, 'Class constraint name is missing');
+  assertNonEmptyString(
+    constraint.name,
+    `Class constraint 'name' field is missing or empty`,
+  );
   assertNonNullable(
     constraint.functionDefinition,
-    'Class constraint function definition is missing',
+    `Class constraint 'functionDefinition' field is missing`,
   );
   const pureConstraint = new Constraint(
     constraint.name,
@@ -91,9 +94,18 @@ export const V1_buildVariable = (
   variable: V1_RawVariable,
   context: V1_GraphBuilderContext,
 ): RawVariableExpression => {
-  assertNonEmptyString(variable.name, 'Variable name is missing');
-  assertNonEmptyString(variable.class, 'Variable class is missing');
-  assertNonNullable(variable.multiplicity, 'Variable multiplicity is missing');
+  assertNonEmptyString(
+    variable.name,
+    `Variable 'name' field is missing or empty`,
+  );
+  assertNonEmptyString(
+    variable.class,
+    `Variable 'class' field is missing or empty`,
+  );
+  assertNonNullable(
+    variable.multiplicity,
+    `Variable 'multiplicity' field is missing`,
+  );
   const multiplicity = context.graph.getMultiplicity(
     variable.multiplicity.lowerBound,
     variable.multiplicity.upperBound,
@@ -108,8 +120,11 @@ export const V1_buildUnit = (
   currentGraph: BasicModel,
   context: V1_GraphBuilderContext,
 ): Unit => {
-  assertNonEmptyString(unit.package, 'Unit package is missing');
-  assertNonEmptyString(unit.name, 'Unit name is missing');
+  assertNonEmptyString(
+    unit.package,
+    `Unit 'package' field is missing or empty`,
+  );
+  assertNonEmptyString(unit.name, `Unit 'name' field is missing or empty`);
   // TODO process unit conversion function, when we start processing value specification, we might want to separate this
   const pureUnit = new Unit(
     unit.name,
@@ -137,9 +152,18 @@ export const V1_buildProperty = (
   context: V1_GraphBuilderContext,
   owner: PropertyOwner,
 ): Property => {
-  assertNonEmptyString(property.name, 'Property name is missing');
-  assertNonEmptyString(property.type, 'Property type is missing');
-  assertNonNullable(property.multiplicity, 'Property multiplicity is missing');
+  assertNonEmptyString(
+    property.name,
+    `Property 'name' field is missing or empty`,
+  );
+  assertNonEmptyString(
+    property.type,
+    `Property 'type' field is missing or empty`,
+  );
+  assertNonNullable(
+    property.multiplicity,
+    `Property 'multiplicity' field is missing or empty`,
+  );
   // NOTE: pass in parent class added for quick conversion to pure protocol down the line
   const pureProperty = new Property(
     property.name,
@@ -164,14 +188,17 @@ export const V1_buildDerivedProperty = (
   context: V1_GraphBuilderContext,
   owner: PropertyOwner,
 ): DerivedProperty => {
-  assertNonEmptyString(property.name, 'Derived property name is missing');
+  assertNonEmptyString(
+    property.name,
+    `Derived property 'name' field is missing or empty`,
+  );
   assertNonEmptyString(
     property.returnType,
-    'Derived property return type is missing',
+    `Derived property 'returnType' field is missing or empty`,
   );
   assertNonNullable(
     property.returnMultiplicity,
-    'Derived property return multiplicity is missing',
+    `Derived property 'returnMultiplicity' field is missing`,
   );
   const derivedProperty = new DerivedProperty(
     property.name,
@@ -206,7 +233,7 @@ export const V1_buildAssociationProperty = (
 ): Property => {
   const associatedPropertyClassType = guaranteeNonNullable(
     associatedProperty.type,
-    'Association associated property type is missing',
+    `Association associated property 'type' field is missing`,
   );
   const associatedClass = context.resolveClass(associatedPropertyClassType);
   const property = V1_buildProperty(currentProperty, context, pureAssociation);

package/src/models/protocols/pure/v1/transformation/pureGraph/to/helpers/V1_FlatDataStoreBuilderHelper.ts

@@ -74,15 +74,15 @@ const buildFlatDataDataType = (
   ): FlatDataRecordField => {
     assertNonEmptyString(
       field.label,
-      'Flat-data record field label is missing',
+      `Flat-data record field 'label' field is missing or empty`,
     );
     assertNonNullable(
       field.flatDataDataType,
-      'Flat-data record field type is missing',
+      `Flat-data record field 'flatDataDataType' field is missing`,
     );
     assertNonNullable(
       field.optional,
-      'Flat-data record field optional flag is missing',
+      `Flat-data record field 'optional' field is missing`,
     );
     const recordField = new FlatDataRecordField(
       field.label,
@@ -162,8 +162,14 @@ const buildFlatDataRecordType = (
 const buildFlatDataProperty = (
   property: V1_FlatDataProperty,
 ): FlatDataProperty => {
-  assertNonEmptyString(property.name, 'Flat-data property name is missing');
-  assertNonNullable(property.value, 'Flat-data property value is missing');
+  assertNonEmptyString(
+    property.name,
+    `Flat-data property 'name' field is missing or empty`,
+  );
+  assertNonNullable(
+    property.value,
+    `Flat-data property 'value' field is missing`,
+  );
   assertTrue(
     isString(property.value) ||
       isNumber(property.value) ||
@@ -178,8 +184,14 @@ export const V1_buildFlatDataSection = (
   parentFlatData: FlatData,
   context: V1_GraphBuilderContext,
 ): FlatDataSection => {
-  assertNonEmptyString(section.name, 'Flat-data section name is missing');
-  assertNonEmptyString(section.driverId, 'Flat-data driver ID is missing');
+  assertNonEmptyString(
+    section.name,
+    `Flat-data section 'name' field is missing or empty`,
+  );
+  assertNonEmptyString(
+    section.driverId,
+    `Flat-data section 'driverId' field is missing`,
+  );
   const flatDataSection = new FlatDataSection(
     section.driverId,
     section.name,

package/src/models/protocols/pure/v1/transformation/pureGraph/to/helpers/V1_GenerationSpecificationBuilderHelper.ts

@@ -28,9 +28,12 @@ export const V1_buildGenerationTreeNode = (
 ): GenerationTreeNode => {
   assertNonEmptyString(
     generationNode.generationElement,
-    'Generation tree node generation element is missing',
+    `Generation tree node 'generationElement' field is missing or empty`,
+  );
+  assertNonEmptyString(
+    generationNode.id,
+    `Generation tree node 'id' field is missing or empty`,
   );
-  assertNonEmptyString(generationNode.id, 'Generation tree node ID is missing');
   const genNode = new GenerationTreeNode(
     context.resolveElement(generationNode.generationElement, false),
   );
@@ -44,7 +47,7 @@ export const V1_buildFileGenerationPointer = (
 ): PackageableElementReference<FileGenerationSpecification> => {
   assertNonEmptyString(
     fileGeneration.path,
-    'File generation pointer path is missing',
+    `File generation pointer 'path' field is missing or empty`,
   );
   return context.resolveFileGeneration(fileGeneration.path);
 };

package/src/models/protocols/pure/v1/transformation/pureGraph/to/helpers/V1_MappingBuilderHelper.ts

@@ -66,6 +66,7 @@ import {
   getRelationalInputType,
   RelationalInputData,
 } from '../../../../../../../metamodels/pure/packageableElements/store/relational/mapping/RelationalInputData';
+import { getAllClassMappings } from '../../../../../../../../helpers/MappingHelper';
 
 export const V1_getInferredClassMappingId = (
   _class: Class,
@@ -84,7 +85,7 @@ const buildEnumValueMapping = (
 ): EnumValueMapping => {
   assertNonNullable(
     srcEnumValueMapping.enumValue,
-    `Enum value mapping enum value name is missing`,
+    `Enum value mapping 'enumValue' field is missing`,
   );
   const enumValueMapping = new EnumValueMapping(
     EnumValueImplicitReference.create(
@@ -131,7 +132,7 @@ export const V1_buildEnumerationMapping = (
 ): EnumerationMapping => {
   assertNonEmptyString(
     srcEnumerationMapping.enumeration,
-    'Enumeration mapping enumeration is missing',
+    `Enumeration mapping 'enumeration' field is missing or empty`,
   );
   const targetEnumeration = context.resolveEnumeration(
     srcEnumerationMapping.enumeration,
@@ -143,7 +144,7 @@ export const V1_buildEnumerationMapping = (
   );
   assertTrue(
     possibleSourceTypes.size <= 1,
-    'Enumeration mapping contains mixed type source values',
+    `Enumeration mapping contains mixed type source values`,
   );
   const sourceTypeInput =
     possibleSourceTypes.size !== 0
@@ -202,15 +203,15 @@ const V1_buildMappingTestInputData = (
   if (inputData instanceof V1_ObjectInputData) {
     assertNonNullable(
       inputData.sourceClass,
-      'Mapping test object input data source class is missing',
+      `Object input data 'sourceClass' field is missing`,
     );
     assertNonNullable(
       inputData.inputType,
-      'Mapping test object input data input type is missing',
+      `Object input data 'inputType' field is missing`,
     );
     assertNonNullable(
       inputData.data,
-      'Mapping test object input data data is missing',
+      `Object input data 'data' field is missing`,
     );
     return new ObjectInputData(
       context.resolveClass(inputData.sourceClass),
@@ -220,11 +221,11 @@ const V1_buildMappingTestInputData = (
   } else if (inputData instanceof V1_FlatDataInputData) {
     assertNonNullable(
       inputData.sourceFlatData,
-      'Mapping test flat-data input data source flat-data is missing',
+      `Flat-data input data 'sourceFlatData' field is missing`,
     );
     assertNonNullable(
       inputData.data,
-      'Mapping test flat-data input data data is missing',
+      `Flat-data input data 'data' field is missing`,
     );
     return new FlatDataInputData(
       context.resolveFlatDataStore(inputData.sourceFlatData.path),
@@ -233,15 +234,15 @@ const V1_buildMappingTestInputData = (
   } else if (inputData instanceof V1_RelationalInputData) {
     assertNonNullable(
       inputData.database,
-      'Mapping test relational input data database is missing',
+      `Relational input data 'database' field is missing`,
     );
     assertNonNullable(
       inputData.inputType,
-      'Mapping test relational input data input type is missing',
+      `Relational input data 'inputType' field is missing`,
     );
     assertNonNullable(
       inputData.data,
-      'Mapping test relational input data data is missing',
+      `Relational input data 'data' field is missing`,
     );
     return new RelationalInputData(
       context.resolveDatabase(inputData.database),
@@ -259,8 +260,11 @@ export const V1_buildMappingTest = (
   mappingTest: V1_MappingTest,
   context: V1_GraphBuilderContext,
 ): MappingTest => {
-  assertNonEmptyString(mappingTest.name, 'Mapping test name is missing');
-  assertNonNullable(mappingTest.query);
+  assertNonEmptyString(
+    mappingTest.name,
+    `Mapping test 'name' field is missing or empty`,
+  );
+  assertNonNullable(mappingTest.query, `Mapping test 'query' field is missing`);
   const query = V1_resolvePathsInRawLambda(
     context,
     mappingTest.query.parameters,
@@ -285,7 +289,7 @@ export const V1_buildMappingTest = (
 
 export const V1_resolveClassMappingRoot = (mapping: Mapping): void => {
   const classToSetImplMap = new Map<Class, Set<SetImplementation>>();
-  mapping.allClassMappings.forEach((setImpl) => {
+  getAllClassMappings(mapping).forEach((setImpl) => {
     const targetClass = guaranteeNonNullable(setImpl.class.value);
     const setImplsWithTargetClass = classToSetImplMap.get(targetClass);
     if (setImplsWithTargetClass) {
@@ -300,7 +304,11 @@ export const V1_resolveClassMappingRoot = (mapping: Mapping): void => {
     const _classMappings = entries[1];
     if (_classMappings.size === 1) {
       const classMapping = Array.from(_classMappings.values())[0];
-      if (classMapping.root.value === false) {
+      // ensure you are only altering current mapping
+      if (
+        classMapping.root.value === false &&
+        classMapping.parent === mapping
+      ) {
         classMapping.root = InferableMappingElementRootImplicitValue.create(
           true,
           classMapping.root.value,

package/src/models/protocols/pure/v1/transformation/pureGraph/to/helpers/V1_RelationalClassMappingBuilderHelper.ts

@@ -77,7 +77,7 @@ export const V1_buildRelationalPrimaryKey = (
   if (rootRelational.groupBy) {
     rootRelational.primaryKey = rootRelational.groupBy.columns;
   } else if (!rootRelational.primaryKey.length) {
-    const relation = rootRelational.mainTableAlias.relation.value;
+    const relation = rootRelational.mainTableAlias?.relation.value;
     const mainTable = rootRelational.mainTableAlias;
     let columns: Column[] = [];
     if (relation instanceof Table || relation instanceof View) {
@@ -90,7 +90,9 @@ export const V1_buildRelationalPrimaryKey = (
       // This might cause bugs in the future.
       // We need more (manual) tests for confidence
       mainTableAlias.column = ColumnExplicitReference.create(col);
-      mainTableAlias.alias = mainTable;
+      if (mainTable) {
+        mainTableAlias.alias = mainTable;
+      }
       return mainTableAlias;
     });
   }

package/src/models/protocols/pure/v1/transformation/pureGraph/to/helpers/V1_RelationalConnectionBuilderHelper.ts

@@ -68,15 +68,15 @@ export const V1_buildDatasourceSpecification = (
   if (protocol instanceof V1_StaticDatasourceSpecification) {
     assertNonEmptyString(
       protocol.host,
-      'Static datasource specification host is missing',
+      `Static datasource specification 'host' field is missing or empty`,
     );
     assertNonEmptyString(
       protocol.databaseName,
-      'Static datasource specification database is missing',
+      `Static datasource specification 'databaseName' field is missing or empty`,
     );
     assertNonNullable(
       protocol.port,
-      'Static datasource specification port is missing',
+      `Static datasource specification 'port' field is missing`,
     );
     const staticSpec = new StaticDatasourceSpecification(
       protocol.host,
@@ -87,15 +87,15 @@ export const V1_buildDatasourceSpecification = (
   } else if (protocol instanceof V1_EmbeddedH2DatasourceSpecification) {
     assertNonEmptyString(
       protocol.databaseName,
-      'Embedded H2 datasource specification databaseName is missing',
+      `Embedded H2 datasource specification 'databaseName' field is missing or empty`,
     );
     assertNonEmptyString(
       protocol.directory,
-      'Embedded H2 datasource specification directory is missing',
+      `Embedded H2 datasource specification 'directory' field is missing or empty`,
     );
     assertNonNullable(
       protocol.autoServerMode,
-      'Embedded H2 datasource specification autoServerMode is missing',
+      `Embedded H2 datasource specification 'autoServerMode' field is missing or empty`,
     );
     const embeddedSpec = new EmbeddedH2DatasourceSpecification(
       protocol.databaseName,
@@ -106,19 +106,19 @@ export const V1_buildDatasourceSpecification = (
   } else if (protocol instanceof V1_SnowflakeDatasourceSpecification) {
     assertNonEmptyString(
       protocol.accountName,
-      'Snowflake datasource specification property is missing',
+      `Snowflake datasource specification 'accountName' field is missing or empty`,
     );
     assertNonEmptyString(
       protocol.region,
-      'Snowflake datasource specification region is missing',
+      `Snowflake datasource specification 'region' field is missing or empty`,
     );
     assertNonEmptyString(
       protocol.warehouseName,
-      'Snowflake datasource specification warehouseName is missing',
+      `Snowflake datasource specification 'warehouseName' field is missing or empty`,
     );
     assertNonNullable(
       protocol.databaseName,
-      'Snowflake datasource specification databaseName is missing',
+      `Snowflake datasource specification 'databaseName' field is missing`,
     );
     const snowflakeSpec = new SnowflakeDatasourceSpecification(
       protocol.accountName,
@@ -129,11 +129,16 @@ export const V1_buildDatasourceSpecification = (
     snowflakeSpec.cloudType = protocol.cloudType;
     snowflakeSpec.quotedIdentifiersIgnoreCase =
       protocol.quotedIdentifiersIgnoreCase;
+    snowflakeSpec.proxyHost = protocol.proxyHost;
+    snowflakeSpec.proxyPort = protocol.proxyPort;
+    snowflakeSpec.nonProxyHosts = protocol.nonProxyHosts;
+    snowflakeSpec.organization = protocol.organization;
+    snowflakeSpec.accountType = protocol.accountType;
     return snowflakeSpec;
   } else if (protocol instanceof V1_BigQueryDatasourceSpecification) {
     assertNonEmptyString(
       protocol.projectId,
-      'BigQuery datasource specification property project ID is missing',
+      `BigQuery datasource specification 'projectId' field is missing or empty`,
     );
     const bigQuerySpec = new BigQueryDatasourceSpecification(
       protocol.projectId,
@@ -148,15 +153,15 @@ export const V1_buildDatasourceSpecification = (
   } else if (protocol instanceof V1_RedshiftDatasourceSpecification) {
     assertNonEmptyString(
       protocol.databaseName,
-      'Redshift datasource specification databaseName is missing',
+      `Redshift datasource specification 'databaseName' field is missing or empty`,
     );
     assertNonEmptyString(
       protocol.endpoint,
-      'Redshift datasource specification endpoint is missing',
+      `Redshift datasource specification 'endpoint' field is missing or empty`,
     );
     assertNonNullable(
       protocol.port,
-      'Redshift datasource specification port is missing',
+      `Redshift datasource specification 'port' field is missing or empty`,
     );
     const redshiftSpec = new RedshiftDatasourceSpecification(
       protocol.databaseName,
@@ -197,15 +202,15 @@ export const V1_buildAuthenticationStrategy = (
   } else if (protocol instanceof V1_SnowflakePublicAuthenticationStrategy) {
     assertNonEmptyString(
       protocol.privateKeyVaultReference,
-      'Snowflake public authentication strategy private key vault reference is missing or empty',
+      `Snowflake public authentication strategy 'privateKeyVaultReference' field is missing or empty`,
     );
     assertNonEmptyString(
       protocol.passPhraseVaultReference,
-      'Snowflake public authentication strategy pass phrase vault reference is missing or empty',
+      `Snowflake public authentication strategy 'passPhraseVaultReference' field is missing or empty`,
     );
     assertNonEmptyString(
       protocol.publicUserName,
-      'Snowflake public authentication user name is missing or empty',
+      `Snowflake public authentication 'publicUserName' field is missing or empty`,
     );
     return new SnowflakePublicAuthenticationStrategy(
       protocol.privateKeyVaultReference,
@@ -233,11 +238,11 @@ export const V1_buildAuthenticationStrategy = (
   } else if (protocol instanceof V1_UserPasswordAuthenticationStrategy) {
     assertNonEmptyString(
       protocol.userName,
-      'User password authentication strategy userName is missing or empty',
+      `User password authentication strategy 'userName' field is missing or empty`,
     );
     assertNonEmptyString(
       protocol.passwordVaultReference,
-      'User password authentication strategy passwordVaultReference is missing or empty',
+      `User password authentication strategy 'passwordVaultReference' field is missing or empty`,
     );
     return new UserPasswordAuthenticationStrategy(
       protocol.userName,

package/src/models/protocols/pure/v1/transformation/pureGraph/to/helpers/V1_RuntimeBuilderHelper.ts

@@ -42,12 +42,12 @@ export const V1_buildEngineRuntime = (
       protocolStoreConnections.storeConnections.map((identifiedConnection) => {
         assertNonEmptyString(
           identifiedConnection.id,
-          'Runtime connection ID is missing',
+          `Runtime connection 'id' field is missing`,
         );
         // make sure runtime connection IDs are unique
         assertTrue(
           !connectionIds.has(identifiedConnection.id),
-          'Runtime connection ID must be unique',
+          `Runtime connection ID must be unique`,
         );
         connectionIds.add(identifiedConnection.id);
         const connection =
@@ -57,7 +57,7 @@ export const V1_buildEngineRuntime = (
         // make sure connection are indexed by store properly
         assertTrue(
           connection.store.value === store.value,
-          'Runtime connections must be correctly indexed by store',
+          `Runtime connections must be correctly indexed by store`,
         );
         return new IdentifiedConnection(identifiedConnection.id, connection);
       });

package/src/models/protocols/pure/v1/transformation/pureGraph/to/helpers/V1_ServiceBuilderHelper.ts

@@ -74,7 +74,7 @@ export const V1_buildServiceTest = (
     assertType(
       parentService.execution,
       PureSingleExecution,
-      'Service with single execution requires a single execution test',
+      'Service with single-execution requires a single-execution test',
     );
     const singleTest = new SingleExecutionTest(parentService, serviceTest.data);
     singleTest.asserts = serviceTest.asserts.map((assert) => {
@@ -94,12 +94,12 @@ export const V1_buildServiceTest = (
     assertType(
       parentService.execution,
       PureMultiExecution,
-      'Service with multi execution requires a multi execution test',
+      'Service with multi-execution requires a multi-execution test',
     );
     const multiTest = new MultiExecutionTest(parentService);
     if (!serviceTest.tests.length) {
       throw new GraphBuilderError(
-        'Service multi execution test must not be empty',
+        'Service multi-execution test must not be empty',
       );
     }
     const executionKeys = new Set(
@@ -111,12 +111,12 @@ export const V1_buildServiceTest = (
     multiTest.tests = serviceTest.tests.map((test) => {
       assertNonEmptyString(
         test.key,
-        'Service multi execution test key is missing',
+        'Service multi-execution test key is missing',
       );
       // check duplicated key
       if (uniqueKeys.has(test.key)) {
         throw new GraphBuilderError(
-          `Service multi execution test with key '${test.key}' already exists`,
+          `Service multi-execution test with key '${test.key}' already exists`,
         );
       }
       uniqueKeys.add(test.key);
@@ -139,14 +139,14 @@ export const V1_buildServiceTest = (
       });
       return keyedTest;
     });
-    // verify matching key values between multi execution and multi execution test
+    // verify matching key values between multi-execution and multi-execution test
     // NOTE: since test depends on execution, we want to check first if no test is found for an execution
     const testWithoutExecutionKeys = new Set(
       Array.from(uniqueKeys.values()).filter((key) => !executionKeys.has(key)),
     );
     Array.from(uniqueKeys.values()).forEach((key) => executionKeys.delete(key));
     /**
-     * Here, we verify matching key values between multi execution and multi test
+     * Here, we verify matching key values between multi-execution and multi test
      * NOTE: since test depends on execution, we definitely want to throw when no execution is found for a test.
      * The other direction is debatable, on one hand it makes sense to have a test for each execution, but very often
      * (and majorly for backward compatibility reasons) we have executions that only differ in connection information
@@ -191,7 +191,10 @@ const buildServiceExecutionRuntime = (
     mapping,
   );
   if (runtime instanceof V1_RuntimePointer) {
-    assertNonNullable(runtime.runtime, 'Runtime pointer path is missing');
+    assertNonNullable(
+      runtime.runtime,
+      `Runtime pointer 'runtime' field is missing`,
+    );
     return new RuntimePointer(context.resolveRuntime(runtime.runtime));
   } else if (runtime instanceof V1_EngineRuntime) {
     runtime.mappings = runtime.mappings.length
@@ -208,7 +211,7 @@ const buildServiceExecutionRuntime = (
     runtime.connections.forEach((connection) => {
       assertNonNullable(
         connection.store,
-        'Legacy runtime embedded connection store is missing',
+        `Legacy runtime embedded connection 'store' field is missing`,
       );
       const identifiedConnection = new V1_IdentifiedConnection();
       identifiedConnection.id = `connection_${idx} `;
@@ -240,7 +243,7 @@ export const V1_buildServiceExecution = (
   if (serviceExecution instanceof V1_PureSingleExecution) {
     assertNonNullable(
       serviceExecution.func,
-      'Service Pure execution function is missing',
+      `Service Pure execution 'func' field is missing`,
     );
     return new PureSingleExecution(
       V1_resolvePathsInRawLambda(
@@ -258,15 +261,15 @@ export const V1_buildServiceExecution = (
     );
   } else if (serviceExecution instanceof V1_PureMultiExecution) {
     if (!serviceExecution.executionParameters.length) {
-      throw new GraphBuilderError('Service multi execution must not be empty');
+      throw new GraphBuilderError('Service multi-execution must not be empty');
     }
     assertNonNullable(
       serviceExecution.func,
-      'Service Pure execution function is missing',
+      `Service Pure execution 'func' field is missing`,
     );
     assertNonEmptyString(
       serviceExecution.executionKey,
-      'Service multi execution key is missing',
+      `Service multi-execution 'executionKey' field is missing`,
     );
     const execution = new PureMultiExecution(
       serviceExecution.executionKey,
@@ -282,12 +285,12 @@ export const V1_buildServiceExecution = (
       (keyedExecutionParameter) => {
         assertNonEmptyString(
           keyedExecutionParameter.key,
-          'Service multi execution parameter key is missing',
+          `Service multi-execution parameter 'key' field is missing`,
         );
         // check duplicated key
         if (uniqueKeys.has(keyedExecutionParameter.key)) {
           throw new GraphBuilderError(
-            `Service multi execution with key '${keyedExecutionParameter.key}' already exists`,
+            `Service multi-execution with key '${keyedExecutionParameter.key}' already exists`,
           );
         }
         return new KeyedExecutionParameter(

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

@@ -98,11 +98,13 @@ export class V1_PackageableElementSerializer
   implements V1_PackageableElementVisitor<PlainObject<V1_PackageableElement>>
 {
   extraElementProtocolSerializers: V1_ElementProtocolSerializer[] = [];
+  plugins: PureProtocolProcessorPlugin[];
 
   constructor(plugins: PureProtocolProcessorPlugin[]) {
     this.extraElementProtocolSerializers = plugins.flatMap(
       (plugin) => plugin.V1_getExtraElementProtocolSerializers?.() ?? [],
     );
+    this.plugins = plugins;
   }
 
   visit_PackageableElement(
@@ -180,7 +182,10 @@ export class V1_PackageableElementSerializer
   visit_PackageableConnection(
     element: V1_PackageableConnection,
   ): PlainObject<V1_PackageableElement> {
-    return serialize(V1_packageableConnectionModelSchema, element);
+    return serialize(
+      V1_packageableConnectionModelSchema(this.plugins),
+      element,
+    );
   }
 
   visit_FileGeneration(
@@ -234,7 +239,7 @@ export const V1_deserializePackageableElement = (
     case V1_SERVICE_ELEMENT_PROTOCOL_TYPE:
       return deserialize(V1_servicedModelSchema, json);
     case V1_PACKAGEABLE_CONNECTION_ELEMENT_PROTOCOL_TYPE:
-      return deserialize(V1_packageableConnectionModelSchema, json);
+      return deserialize(V1_packageableConnectionModelSchema(plugins), json);
     case V1_PACKAGEABLE_RUNTIME_ELEMENT_PROTOCOL_TYPE:
       return deserialize(V1_packageableRuntimeModelSchema, json);
     case V1_FILE_GENERATION_ELEMENT_PROTOCOL_TYPE: