@finos/legend-graph 4.0.3 → 6.0.1

package/src/models/protocols/pure/v1/transformation/pureProtocol/serializationHelpers/V1_DomainSerializationHelper.ts

@@ -104,28 +104,30 @@ export const V1_enumValueSchema = createModelSchema(V1_EnumValue, {
       serializeArray(
         values,
         (value) => serialize(V1_stereotypePtrSchema, value),
-        true,
+        {
+          skipIfEmpty: true,
+          INTERNAL__forceReturnEmptyInTest: true,
+        },
       ),
     (values) =>
-      deserializeArray(
-        values,
-        (v: V1_StereotypePtr) => deserialize(V1_stereotypePtrSchema, v),
-        false,
-      ),
+      deserializeArray(values, (v) => deserialize(V1_stereotypePtrSchema, v), {
+        skipIfEmpty: false,
+      }),
   ),
   taggedValues: custom(
     (values) =>
       serializeArray(
         values,
         (value) => serialize(V1_taggedValueSchema, value),
-        true,
+        {
+          skipIfEmpty: true,
+          INTERNAL__forceReturnEmptyInTest: true,
+        },
       ),
     (values) =>
-      deserializeArray(
-        values,
-        (v: V1_StereotypePtr) => deserialize(V1_taggedValueSchema, v),
-        false,
-      ),
+      deserializeArray(values, (v) => deserialize(V1_taggedValueSchema, v), {
+        skipIfEmpty: false,
+      }),
   ),
   value: primitive(),
 });
@@ -139,28 +141,30 @@ export const V1_enumerationSchema = createModelSchema(V1_Enumeration, {
       serializeArray(
         values,
         (value) => serialize(V1_stereotypePtrSchema, value),
-        true,
+        {
+          skipIfEmpty: true,
+          INTERNAL__forceReturnEmptyInTest: true,
+        },
       ),
     (values) =>
-      deserializeArray(
-        values,
-        (v: V1_StereotypePtr) => deserialize(V1_stereotypePtrSchema, v),
-        false,
-      ),
+      deserializeArray(values, (v) => deserialize(V1_stereotypePtrSchema, v), {
+        skipIfEmpty: false,
+      }),
   ),
   taggedValues: custom(
     (values) =>
       serializeArray(
         values,
         (value) => serialize(V1_taggedValueSchema, value),
-        true,
+        {
+          skipIfEmpty: true,
+          INTERNAL__forceReturnEmptyInTest: true,
+        },
       ),
     (values) =>
-      deserializeArray(
-        values,
-        (v: V1_StereotypePtr) => deserialize(V1_taggedValueSchema, v),
-        false,
-      ),
+      deserializeArray(values, (v) => deserialize(V1_taggedValueSchema, v), {
+        skipIfEmpty: false,
+      }),
   ),
   values: list(usingModelSchema(V1_enumValueSchema)),
 });
@@ -193,28 +197,30 @@ export const V1_propertySchema = createModelSchema(V1_Property, {
       serializeArray(
         values,
         (value) => serialize(V1_stereotypePtrSchema, value),
-        true,
+        {
+          skipIfEmpty: true,
+          INTERNAL__forceReturnEmptyInTest: true,
+        },
       ),
     (values) =>
-      deserializeArray(
-        values,
-        (v: V1_StereotypePtr) => deserialize(V1_stereotypePtrSchema, v),
-        false,
-      ),
+      deserializeArray(values, (v) => deserialize(V1_stereotypePtrSchema, v), {
+        skipIfEmpty: false,
+      }),
   ),
   taggedValues: custom(
     (values) =>
       serializeArray(
         values,
         (value) => serialize(V1_taggedValueSchema, value),
-        true,
+        {
+          skipIfEmpty: true,
+          INTERNAL__forceReturnEmptyInTest: true,
+        },
       ),
     (values) =>
-      deserializeArray(
-        values,
-        (v: V1_StereotypePtr) => deserialize(V1_taggedValueSchema, v),
-        false,
-      ),
+      deserializeArray(values, (v) => deserialize(V1_taggedValueSchema, v), {
+        skipIfEmpty: false,
+      }),
   ),
   type: primitive(),
 });
@@ -230,28 +236,30 @@ export const V1_derivedPropertySchema = createModelSchema(V1_DerivedProperty, {
       serializeArray(
         values,
         (value) => serialize(V1_stereotypePtrSchema, value),
-        true,
+        {
+          skipIfEmpty: true,
+          INTERNAL__forceReturnEmptyInTest: true,
+        },
       ),
     (values) =>
-      deserializeArray(
-        values,
-        (v: V1_StereotypePtr) => deserialize(V1_stereotypePtrSchema, v),
-        false,
-      ),
+      deserializeArray(values, (v) => deserialize(V1_stereotypePtrSchema, v), {
+        skipIfEmpty: false,
+      }),
   ),
   taggedValues: custom(
     (values) =>
       serializeArray(
         values,
         (value) => serialize(V1_taggedValueSchema, value),
-        true,
+        {
+          skipIfEmpty: true,
+          INTERNAL__forceReturnEmptyInTest: true,
+        },
       ),
     (values) =>
-      deserializeArray(
-        values,
-        (v: V1_StereotypePtr) => deserialize(V1_taggedValueSchema, v),
-        false,
-      ),
+      deserializeArray(values, (v) => deserialize(V1_taggedValueSchema, v), {
+        skipIfEmpty: false,
+      }),
   ),
 });
 
@@ -267,37 +275,46 @@ export const V1_classSchema = createModelSchema(V1_Class, {
   _type: usingConstantValueSchema(V1_CLASS_ELEMENT_PROTOCOL_TYPE),
   constraints: custom(
     (values) =>
-      serializeArray(
-        values,
-        (value) => serialize(V1_constraintSchema, value),
-        true,
-      ),
+      serializeArray(values, (value) => serialize(V1_constraintSchema, value), {
+        skipIfEmpty: true,
+        INTERNAL__forceReturnEmptyInTest: true,
+      }),
     (values) =>
-      deserializeArray(
-        values,
-        (v: V1_StereotypePtr) => deserialize(V1_constraintSchema, v),
-        false,
-      ),
+      deserializeArray(values, (v) => deserialize(V1_constraintSchema, v), {
+        skipIfEmpty: false,
+      }),
   ),
   name: primitive(),
+  /**
+   * Omit this information during protocol transformation as it can be
+   * interpreted while building the graph; and will help grammar-roundtrip
+   * tests (involving engine) to pass. Ideally, this requires grammar parser
+   * and composer in engine to be more consistent.
+   *
+   * @discrepancy grammar-roundtrip
+   */
   originalMilestonedProperties: custom(
-    (values) => serializeArray([], () => SKIP, true),
-    (values) => deserializeArray([], () => SKIP, false),
-  ), // @MARKER: GRAMMAR ROUNDTRIP --- omit this information during protocol transformation as it can be interpreted while building the graph
+    (values) =>
+      serializeArray(values, (value) => SKIP, {
+        skipIfEmpty: true,
+        INTERNAL__forceReturnEmptyInTest: true,
+      }),
+    (values) =>
+      deserializeArray(values, (v) => SKIP, {
+        skipIfEmpty: false,
+      }),
+  ),
   package: primitive(),
   properties: custom(
     (values) =>
-      serializeArray(
-        values,
-        (value) => serialize(V1_propertySchema, value),
-        true,
-      ),
+      serializeArray(values, (value) => serialize(V1_propertySchema, value), {
+        skipIfEmpty: true,
+        INTERNAL__forceReturnEmptyInTest: true,
+      }),
     (values) =>
-      deserializeArray(
-        values,
-        (v: V1_StereotypePtr) => deserialize(V1_propertySchema, v),
-        false,
-      ),
+      deserializeArray(values, (v) => deserialize(V1_propertySchema, v), {
+        skipIfEmpty: false,
+      }),
   ),
   derivedProperties: alias(
     'qualifiedProperties', // 'derived properties' used to be called 'qualified properties'
@@ -306,13 +323,18 @@ export const V1_classSchema = createModelSchema(V1_Class, {
         serializeArray(
           values,
           (value) => serialize(V1_derivedPropertySchema, value),
-          true,
+          {
+            skipIfEmpty: true,
+            INTERNAL__forceReturnEmptyInTest: true,
+          },
         ),
       (values) =>
         deserializeArray(
           values,
-          (v: V1_StereotypePtr) => deserialize(V1_derivedPropertySchema, v),
-          false,
+          (v) => deserialize(V1_derivedPropertySchema, v),
+          {
+            skipIfEmpty: false,
+          },
         ),
     ),
   ),
@@ -321,32 +343,41 @@ export const V1_classSchema = createModelSchema(V1_Class, {
       serializeArray(
         values,
         (value) => serialize(V1_stereotypePtrSchema, value),
-        true,
+        {
+          skipIfEmpty: true,
+          INTERNAL__forceReturnEmptyInTest: true,
+        },
       ),
     (values) =>
-      deserializeArray(
-        values,
-        (v: V1_StereotypePtr) => deserialize(V1_stereotypePtrSchema, v),
-        false,
-      ),
+      deserializeArray(values, (v) => deserialize(V1_stereotypePtrSchema, v), {
+        skipIfEmpty: false,
+      }),
   ),
   superTypes: custom(
-    (values) => serializeArray(values, (value) => value, true),
-    (values) => deserializeArray(values, (v: string) => v, false),
+    (values) =>
+      serializeArray(values, (value: string) => value, {
+        skipIfEmpty: true,
+        INTERNAL__forceReturnEmptyInTest: true,
+      }),
+    (values) =>
+      deserializeArray(values, (v) => v, {
+        skipIfEmpty: false,
+      }),
   ),
   taggedValues: custom(
     (values) =>
       serializeArray(
         values,
         (value) => serialize(V1_taggedValueSchema, value),
-        true,
+        {
+          skipIfEmpty: true,
+          INTERNAL__forceReturnEmptyInTest: true,
+        },
       ),
     (values) =>
-      deserializeArray(
-        values,
-        (v: V1_StereotypePtr) => deserialize(V1_taggedValueSchema, v),
-        false,
-      ),
+      deserializeArray(values, (v) => deserialize(V1_taggedValueSchema, v), {
+        skipIfEmpty: false,
+      }),
   ),
 });
 
@@ -357,10 +388,25 @@ export const V1_associationSchema = createModelSchema(V1_Association, {
   name: primitive(),
   package: primitive(),
   properties: list(usingModelSchema(V1_propertySchema)),
+  /**
+   * Omit this information during protocol transformation as it can be
+   * interpreted while building the graph; and will help grammar-roundtrip
+   * tests (involving engine) to pass. Ideally, this requires grammar parser
+   * and composer in engine to be more consistent.
+   *
+   * @discrepancy grammar-roundtrip
+   */
   originalMilestonedProperties: custom(
-    (values) => serializeArray([], () => SKIP, true),
-    (values) => deserializeArray([], () => SKIP, false),
-  ), // @MARKER: GRAMMAR ROUNDTRIP --- omit this information during protocol transformation as it can be interpreted while building the graph
+    (values) =>
+      serializeArray(values, (value) => SKIP, {
+        skipIfEmpty: true,
+        INTERNAL__forceReturnEmptyInTest: true,
+      }),
+    (values) =>
+      deserializeArray(values, (v) => SKIP, {
+        skipIfEmpty: false,
+      }),
+  ),
   derivedProperties: alias(
     'qualifiedProperties', // 'derived properties' used to be called 'qualified properties'
     custom(
@@ -368,13 +414,18 @@ export const V1_associationSchema = createModelSchema(V1_Association, {
         serializeArray(
           values,
           (value) => serialize(V1_derivedPropertySchema, value),
-          true,
+          {
+            skipIfEmpty: true,
+            INTERNAL__forceReturnEmptyInTest: true,
+          },
         ),
       (values) =>
         deserializeArray(
           values,
-          (v: V1_StereotypePtr) => deserialize(V1_derivedPropertySchema, v),
-          false,
+          (v) => deserialize(V1_derivedPropertySchema, v),
+          {
+            skipIfEmpty: false,
+          },
         ),
     ),
   ),
@@ -383,28 +434,30 @@ export const V1_associationSchema = createModelSchema(V1_Association, {
       serializeArray(
         values,
         (value) => serialize(V1_stereotypePtrSchema, value),
-        true,
+        {
+          skipIfEmpty: true,
+          INTERNAL__forceReturnEmptyInTest: true,
+        },
       ),
     (values) =>
-      deserializeArray(
-        values,
-        (v: V1_StereotypePtr) => deserialize(V1_stereotypePtrSchema, v),
-        false,
-      ),
+      deserializeArray(values, (v) => deserialize(V1_stereotypePtrSchema, v), {
+        skipIfEmpty: false,
+      }),
   ),
   taggedValues: custom(
     (values) =>
       serializeArray(
         values,
         (value) => serialize(V1_taggedValueSchema, value),
-        true,
+        {
+          skipIfEmpty: true,
+          INTERNAL__forceReturnEmptyInTest: true,
+        },
       ),
     (values) =>
-      deserializeArray(
-        values,
-        (v: V1_StereotypePtr) => deserialize(V1_taggedValueSchema, v),
-        false,
-      ),
+      deserializeArray(values, (v) => deserialize(V1_taggedValueSchema, v), {
+        skipIfEmpty: false,
+      }),
   ),
 });
 
@@ -425,13 +478,18 @@ export const V1_functionSchema = createModelSchema(
         serializeArray(
           values,
           (value) => serialize(V1_stereotypePtrSchema, value),
-          true,
+          {
+            skipIfEmpty: true,
+            INTERNAL__forceReturnEmptyInTest: true,
+          },
         ),
       (values) =>
         deserializeArray(
           values,
-          (v: V1_StereotypePtr) => deserialize(V1_stereotypePtrSchema, v),
-          false,
+          (v) => deserialize(V1_stereotypePtrSchema, v),
+          {
+            skipIfEmpty: false,
+          },
         ),
     ),
     taggedValues: custom(
@@ -439,14 +497,15 @@ export const V1_functionSchema = createModelSchema(
         serializeArray(
           values,
           (value) => serialize(V1_taggedValueSchema, value),
-          true,
+          {
+            skipIfEmpty: true,
+            INTERNAL__forceReturnEmptyInTest: true,
+          },
         ),
       (values) =>
-        deserializeArray(
-          values,
-          (v: V1_StereotypePtr) => deserialize(V1_taggedValueSchema, v),
-          false,
-        ),
+        deserializeArray(values, (v) => deserialize(V1_taggedValueSchema, v), {
+          skipIfEmpty: false,
+        }),
     ),
   },
 );

package/src/models/protocols/pure/v1/transformation/pureProtocol/serializationHelpers/V1_GenerationSpecificationSerializationHelper.ts

@@ -34,8 +34,15 @@ export const V1_generationTreeNodeModelSchema = createModelSchema(
   V1_GenerationTreeNode,
   {
     children: custom(
-      (values) => serializeArray(values, (value) => value, true),
-      (values) => deserializeArray(values, (value) => value, false),
+      (values) =>
+        serializeArray(values, (value) => value, {
+          skipIfEmpty: true,
+          INTERNAL__forceReturnEmptyInTest: true,
+        }),
+      (values) =>
+        deserializeArray(values, (value) => value, {
+          skipIfEmpty: false,
+        }),
     ),
     generationElement: primitive(),
     id: primitive(),

package/src/models/protocols/pure/v1/transformation/pureProtocol/serializationHelpers/V1_MappingSerializationHelper.ts

@@ -21,10 +21,10 @@ import {
   primitive,
   deserialize,
   serialize,
-  SKIP,
   custom,
   optional,
   raw,
+  SKIP,
 } from 'serializr';
 import {
   type PlainObject,
@@ -101,6 +101,7 @@ import type { DSLMapping_PureProtocolProcessorPlugin_Extension } from '../../../
 import type { PureProtocolProcessorPlugin } from '../../../../PureProtocolProcessorPlugin';
 import { V1_BindingTransformer } from '../../../model/packageableElements/externalFormat/store/V1_BindingTransformer';
 import { V1_MergeOperationClassMapping } from '../../../model/packageableElements/mapping/V1_MergeOperationClassMapping';
+import type { V1_RelationalOperationElement } from '../../../model/packageableElements/store/relational/model/V1_RelationalOperationElement';
 
 enum V1_ClassMappingType {
   OPERATION = 'operation',
@@ -231,14 +232,20 @@ const rootRelationalClassMappingModelSchema = createModelSchema(
       (values) =>
         serializeArray(
           values,
-          (value) => V1_serializeRelationalOperationElement(value),
-          true,
+          (value: V1_RelationalOperationElement) =>
+            V1_serializeRelationalOperationElement(value),
+          {
+            skipIfEmpty: true,
+            INTERNAL__forceReturnEmptyInTest: true,
+          },
         ),
       (values) =>
         deserializeArray(
           values,
           (val) => V1_deserializeRelationalOperationElement(val),
-          false,
+          {
+            skipIfEmpty: false,
+          },
         ),
     ),
     id: optional(primitive()),
@@ -315,7 +322,15 @@ const embeddedRelationalPropertyMappingModelSchema = createModelSchema(
       V1_localMappingPropertyInfoModelSchema,
     ),
     property: usingModelSchema(V1_propertyPointerModelSchema),
-    source: optional(primitive()), // @MARKER: GRAMMAR ROUNDTRIP --- omit this information during protocol transformation as it can be interpreted while building the graph
+    /**
+     * Omit this information during protocol transformation as it can be
+     * interpreted while building the graph; and will help grammar-roundtrip
+     * tests (involving engine) to pass. Ideally, this requires grammar parser
+     * and composer in engine to be more consistent.
+     *
+     * @discrepancy grammar-roundtrip
+     */
+    source: optional(primitive()),
     target: optional(primitive()),
   },
 );
@@ -331,7 +346,15 @@ const otherwiseEmbeddedRelationalPropertyMappingModelSchgema =
       (val) => V1_deserializeRelationalPropertyMapping(val),
     ),
     property: usingModelSchema(V1_propertyPointerModelSchema),
-    source: optional(primitive()), // @MARKER: GRAMMAR ROUNDTRIP --- omit this information during protocol transformation as it can be interpreted while building the graph
+    /**
+     * Omit this information during protocol transformation as it can be
+     * interpreted while building the graph; and will help grammar-roundtrip
+     * tests (involving engine) to pass. Ideally, this requires grammar parser
+     * and composer in engine to be more consistent.
+     *
+     * @discrepancy grammar-roundtrip
+     */
+    source: optional(primitive()),
     target: optional(primitive()),
     localMappingProperty: usingModelSchema(
       V1_localMappingPropertyInfoModelSchema,
@@ -349,7 +372,15 @@ const inlineEmbeddedPropertyMappingModelSchema = createModelSchema(
       V1_localMappingPropertyInfoModelSchema,
     ),
     property: usingModelSchema(V1_propertyPointerModelSchema),
-    source: optional(primitive()), // @MARKER: GRAMMAR ROUNDTRIP --- omit this information during protocol transformation as it can be interpreted while building the graph
+    /**
+     * Omit this information during protocol transformation as it can be
+     * interpreted while building the graph; and will help grammar-roundtrip
+     * tests (involving engine) to pass. Ideally, this requires grammar parser
+     * and composer in engine to be more consistent.
+     *
+     * @discrepancy grammar-roundtrip
+     */
+    source: optional(primitive()),
     setImplementationId: primitive(),
     target: optional(primitive()),
   },
@@ -711,7 +742,7 @@ const V1_expectedOutputMappingTestAssertModelSchema = createModelSchema(
 
 const V1_serializeInputData = (
   protocol: V1_InputData,
-): PlainObject<V1_InputData> | typeof SKIP => {
+): PlainObject<V1_InputData> => {
   if (protocol instanceof V1_ObjectInputData) {
     return serialize(V1_objectInputData, protocol);
   } else if (protocol instanceof V1_FlatDataInputData) {
@@ -719,12 +750,15 @@ const V1_serializeInputData = (
   } else if (protocol instanceof V1_RelationalInputData) {
     return serialize(V1_relationalInputData, protocol);
   }
-  return SKIP;
+  throw new UnsupportedOperationError(
+    `Can't serialize mapping test input data`,
+    protocol,
+  );
 };
 
 const V1_deserializeInputData = (
   json: PlainObject<V1_InputData>,
-): V1_InputData | typeof SKIP => {
+): V1_InputData => {
   switch (json._type) {
     case V1_InputDataType.OBJECT:
       return deserialize(V1_objectInputData, json);
@@ -733,27 +767,35 @@ const V1_deserializeInputData = (
     case V1_InputDataType.RELATIONAL:
       return deserialize(V1_relationalInputData, json);
     default:
-      return SKIP;
+      throw new UnsupportedOperationError(
+        `Can't deserialize mapping test input data of type '${json._type}'`,
+      );
   }
 };
 
 const V1_serializeTestAssert = (
   protocol: V1_MappingTestAssert,
-): PlainObject<V1_MappingTestAssert> | typeof SKIP => {
+): PlainObject<V1_MappingTestAssert> => {
   if (protocol instanceof V1_ExpectedOutputMappingTestAssert) {
     return serialize(V1_expectedOutputMappingTestAssertModelSchema, protocol);
   }
-  return SKIP;
+
+  throw new UnsupportedOperationError(
+    `Can't serialize mapping test assert`,
+    protocol,
+  );
 };
 
 const V1_deserializeTestAssert = (
   json: PlainObject<V1_MappingTestAssert>,
-): V1_MappingTestAssert | typeof SKIP => {
+): V1_MappingTestAssert => {
   switch (json._type) {
     case V1_MappingTestAssertType.EXPECTED_OUTPUT_MAPPING_TEST_ASSERT:
       return deserialize(V1_expectedOutputMappingTestAssertModelSchema, json);
     default:
-      return SKIP;
+      throw new UnsupportedOperationError(
+        `Can't deserialize mapping test assert of type '${json._type}'`,
+      );
   }
 };
 
@@ -837,25 +879,30 @@ const xStoreAssociationMappingModelschema = createModelSchema(
 
 const V1_serializeAssociationMapping = (
   protocol: V1_AssociationMapping,
-): PlainObject<V1_AssociationMapping> | typeof SKIP => {
+): PlainObject<V1_AssociationMapping> => {
   if (protocol instanceof V1_RelationalAssociationMapping) {
     return serialize(relationalAssociationMappingModelschema, protocol);
   } else if (protocol instanceof V1_XStoreAssociationMapping) {
     return serialize(xStoreAssociationMappingModelschema, protocol);
   }
-  return SKIP;
+  throw new UnsupportedOperationError(
+    `Can't serialize association mapping`,
+    protocol,
+  );
 };
 
 const V1_deserializeAssociationMapping = (
   json: PlainObject<V1_AssociationMapping>,
-): V1_AssociationMapping | typeof SKIP => {
+): V1_AssociationMapping => {
   switch (json._type) {
     case V1_AssociationMappingType.RELATIONAL:
       return deserialize(relationalAssociationMappingModelschema, json);
     case V1_AssociationMappingType.XSTORE:
       return deserialize(xStoreAssociationMappingModelschema, json);
     default:
-      return SKIP;
+      throw new UnsupportedOperationError(
+        `Can't deserialize association mapping of type '${json._type}'`,
+      );
   }
 };
 
@@ -1023,15 +1070,20 @@ export const V1_mappingModelSchema = (
       (values) =>
         serializeArray(
           values,
-          (value) => V1_serializeAssociationMapping(value),
-          true,
+          (value: V1_AssociationMapping) =>
+            V1_serializeAssociationMapping(value),
+          {
+            skipIfEmpty: true,
+            INTERNAL__forceReturnEmptyInTest: true,
+          },
         ),
       (values) =>
         deserializeArray(
           values,
-          (val: PlainObject<V1_AssociationMapping>) =>
-            V1_deserializeAssociationMapping(val),
-          false,
+          (val) => V1_deserializeAssociationMapping(val),
+          {
+            skipIfEmpty: false,
+          },
         ),
     ),
     classMappings: list(