@finos/legend-graph 28.1.8 → 29.0.1

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

@@ -71,22 +71,22 @@ export const V1_propertyPointerModelSchema = createModelSchema(
 
 // ------------------------------------- Profile -------------------------------------
 
-export const V1_stereotypePtrSchema = createModelSchema(V1_StereotypePtr, {
+export const V1_stereotypePtrModelSchema = createModelSchema(V1_StereotypePtr, {
   profile: primitive(),
   value: primitive(),
 });
 
-export const V1_tagPtrSchema = createModelSchema(V1_TagPtr, {
+export const V1_tagPtrModelSchema = createModelSchema(V1_TagPtr, {
   profile: primitive(),
   value: primitive(),
 });
 
-export const V1_taggedValueSchema = createModelSchema(V1_TaggedValue, {
-  tag: usingModelSchema(V1_tagPtrSchema),
+export const V1_taggedValueModelSchema = createModelSchema(V1_TaggedValue, {
+  tag: usingModelSchema(V1_tagPtrModelSchema),
   value: primitive(),
 });
 
-export const V1_profileSchema = createModelSchema(V1_Profile, {
+export const V1_profileModelSchema = createModelSchema(V1_Profile, {
   _type: usingConstantValueSchema(V1_PROFILE_ELEMENT_PROTOCOL_TYPE),
   name: primitive(),
   package: primitive(),
@@ -96,32 +96,32 @@ export const V1_profileSchema = createModelSchema(V1_Profile, {
 
 // ------------------------------------- Enumeration -------------------------------------
 
-export const V1_enumValueSchema = createModelSchema(V1_EnumValue, {
-  stereotypes: customListWithSchema(V1_stereotypePtrSchema, {
+export const V1_enumValueModelSchema = createModelSchema(V1_EnumValue, {
+  stereotypes: customListWithSchema(V1_stereotypePtrModelSchema, {
     INTERNAL__forceReturnEmptyInTest: true,
   }),
-  taggedValues: customListWithSchema(V1_taggedValueSchema, {
+  taggedValues: customListWithSchema(V1_taggedValueModelSchema, {
     INTERNAL__forceReturnEmptyInTest: true,
   }),
   value: primitive(),
 });
 
-export const V1_enumerationSchema = createModelSchema(V1_Enumeration, {
+export const V1_enumerationModelSchema = createModelSchema(V1_Enumeration, {
   _type: usingConstantValueSchema(V1_ENUMERATION_ELEMENT_PROTOCOL_TYPE),
   name: primitive(),
   package: primitive(),
-  stereotypes: customListWithSchema(V1_stereotypePtrSchema, {
+  stereotypes: customListWithSchema(V1_stereotypePtrModelSchema, {
     INTERNAL__forceReturnEmptyInTest: true,
   }),
-  taggedValues: customListWithSchema(V1_taggedValueSchema, {
+  taggedValues: customListWithSchema(V1_taggedValueModelSchema, {
     INTERNAL__forceReturnEmptyInTest: true,
   }),
-  values: list(usingModelSchema(V1_enumValueSchema)),
+  values: list(usingModelSchema(V1_enumValueModelSchema)),
 });
 
 // ------------------------------------- Measure -------------------------------------
 
-export const V1_unitSchema = createModelSchema(V1_Unit, {
+export const V1_unitModelSchema = createModelSchema(V1_Unit, {
   _type: usingConstantValueSchema(V1_UNIT_ELEMENT_PROTOCOL_TYPE),
   conversionFunction: optional(usingModelSchema(V1_rawLambdaModelSchema)),
   measure: primitive(),
@@ -129,44 +129,47 @@ export const V1_unitSchema = createModelSchema(V1_Unit, {
   package: primitive(),
 });
 
-export const V1_measureSchema = createModelSchema(V1_Measure, {
+export const V1_measureModelSchema = createModelSchema(V1_Measure, {
   _type: usingConstantValueSchema(V1_MEASURE_ELEMENT_PROTOCOL_TYPE),
-  canonicalUnit: optional(usingModelSchema(V1_unitSchema)),
+  canonicalUnit: optional(usingModelSchema(V1_unitModelSchema)),
   name: primitive(),
-  nonCanonicalUnits: list(usingModelSchema(V1_unitSchema)),
+  nonCanonicalUnits: list(usingModelSchema(V1_unitModelSchema)),
   package: primitive(),
 });
 
 // ------------------------------------- Class -------------------------------------
 
-export const V1_propertySchema = createModelSchema(V1_Property, {
+export const V1_propertyModelSchema = createModelSchema(V1_Property, {
   aggregation: optional(primitive()),
   multiplicity: usingModelSchema(V1_multiplicityModelSchema),
   name: primitive(),
-  stereotypes: customListWithSchema(V1_stereotypePtrSchema, {
+  stereotypes: customListWithSchema(V1_stereotypePtrModelSchema, {
     INTERNAL__forceReturnEmptyInTest: true,
   }),
-  taggedValues: customListWithSchema(V1_taggedValueSchema, {
+  taggedValues: customListWithSchema(V1_taggedValueModelSchema, {
     INTERNAL__forceReturnEmptyInTest: true,
   }),
   type: primitive(),
 });
 
-export const V1_derivedPropertySchema = createModelSchema(V1_DerivedProperty, {
-  body: raw(),
-  name: primitive(),
-  parameters: raw(),
-  returnMultiplicity: usingModelSchema(V1_multiplicityModelSchema),
-  returnType: primitive(),
-  stereotypes: customListWithSchema(V1_stereotypePtrSchema, {
-    INTERNAL__forceReturnEmptyInTest: true,
-  }),
-  taggedValues: customListWithSchema(V1_taggedValueSchema, {
-    INTERNAL__forceReturnEmptyInTest: true,
-  }),
-});
+export const V1_derivedPropertyModelSchema = createModelSchema(
+  V1_DerivedProperty,
+  {
+    body: raw(),
+    name: primitive(),
+    parameters: raw(),
+    returnMultiplicity: usingModelSchema(V1_multiplicityModelSchema),
+    returnType: primitive(),
+    stereotypes: customListWithSchema(V1_stereotypePtrModelSchema, {
+      INTERNAL__forceReturnEmptyInTest: true,
+    }),
+    taggedValues: customListWithSchema(V1_taggedValueModelSchema, {
+      INTERNAL__forceReturnEmptyInTest: true,
+    }),
+  },
+);
 
-export const V1_constraintSchema = createModelSchema(V1_Constraint, {
+export const V1_constraintModelSchema = createModelSchema(V1_Constraint, {
   enforcementLevel: optional(primitive()),
   externalId: optional(primitive()),
   functionDefinition: usingModelSchema(V1_rawLambdaModelSchema),
@@ -174,9 +177,9 @@ export const V1_constraintSchema = createModelSchema(V1_Constraint, {
   name: primitive(),
 });
 
-export const V1_classSchema = createModelSchema(V1_Class, {
+export const V1_classModelSchema = createModelSchema(V1_Class, {
   _type: usingConstantValueSchema(V1_CLASS_ELEMENT_PROTOCOL_TYPE),
-  constraints: customListWithSchema(V1_constraintSchema, {
+  constraints: customListWithSchema(V1_constraintModelSchema, {
     INTERNAL__forceReturnEmptyInTest: true,
   }),
   name: primitive(),
@@ -196,29 +199,29 @@ export const V1_classSchema = createModelSchema(V1_Class, {
     },
   ),
   package: primitive(),
-  properties: customListWithSchema(V1_propertySchema, {
+  properties: customListWithSchema(V1_propertyModelSchema, {
     INTERNAL__forceReturnEmptyInTest: true,
   }),
   derivedProperties: alias(
     'qualifiedProperties', // 'derived properties' used to be called 'qualified properties'
-    customListWithSchema(V1_derivedPropertySchema, {
+    customListWithSchema(V1_derivedPropertyModelSchema, {
       INTERNAL__forceReturnEmptyInTest: true,
     }),
   ),
-  stereotypes: customListWithSchema(V1_stereotypePtrSchema, {
+  stereotypes: customListWithSchema(V1_stereotypePtrModelSchema, {
     INTERNAL__forceReturnEmptyInTest: true,
   }),
   superTypes: customEquivalentList({
     INTERNAL__forceReturnEmptyInTest: true,
   }),
-  taggedValues: customListWithSchema(V1_taggedValueSchema, {
+  taggedValues: customListWithSchema(V1_taggedValueModelSchema, {
     INTERNAL__forceReturnEmptyInTest: true,
   }),
 });
 
 // ------------------------------------- Association -------------------------------------
 
-export const V1_associationSchema = createModelSchema(V1_Association, {
+export const V1_associationModelSchema = createModelSchema(V1_Association, {
   _type: usingConstantValueSchema(V1_ASSOCIATION_ELEMENT_PROTOCOL_TYPE),
   name: primitive(),
   /**
@@ -237,24 +240,24 @@ export const V1_associationSchema = createModelSchema(V1_Association, {
     },
   ),
   package: primitive(),
-  properties: list(usingModelSchema(V1_propertySchema)),
+  properties: list(usingModelSchema(V1_propertyModelSchema)),
   derivedProperties: alias(
     'qualifiedProperties', // 'derived properties' used to be called 'qualified properties'
-    customListWithSchema(V1_derivedPropertySchema, {
+    customListWithSchema(V1_derivedPropertyModelSchema, {
       INTERNAL__forceReturnEmptyInTest: true,
     }),
   ),
-  stereotypes: customListWithSchema(V1_stereotypePtrSchema, {
+  stereotypes: customListWithSchema(V1_stereotypePtrModelSchema, {
     INTERNAL__forceReturnEmptyInTest: true,
   }),
-  taggedValues: customListWithSchema(V1_taggedValueSchema, {
+  taggedValues: customListWithSchema(V1_taggedValueModelSchema, {
     INTERNAL__forceReturnEmptyInTest: true,
   }),
 });
 
 // ------------------------------------- Function -------------------------------------
 
-export const V1_functionSchema = createModelSchema(
+export const V1_functionModelSchema = createModelSchema(
   V1_ConcreteFunctionDefinition,
   {
     _type: usingConstantValueSchema(V1_FUNCTION_ELEMENT_PROTOCOL_TYPE),
@@ -266,10 +269,10 @@ export const V1_functionSchema = createModelSchema(
     preConstraints: list(primitive()), // NOTE: these are not currently supported and just added to pass roundtrip test
     returnMultiplicity: usingModelSchema(V1_multiplicityModelSchema),
     returnType: primitive(),
-    stereotypes: customListWithSchema(V1_stereotypePtrSchema, {
+    stereotypes: customListWithSchema(V1_stereotypePtrModelSchema, {
       INTERNAL__forceReturnEmptyInTest: true,
     }),
-    taggedValues: customListWithSchema(V1_taggedValueSchema, {
+    taggedValues: customListWithSchema(V1_taggedValueModelSchema, {
       INTERNAL__forceReturnEmptyInTest: true,
     }),
   },

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

@@ -133,6 +133,7 @@ import {
   V1_MappingQueryTest,
 } from '../../../model/packageableElements/mapping/V1_MappingTest.js';
 import type { V1_TestSuite } from '../../../model/test/V1_TestSuite.js';
+import { V1_INTERNAL__UnknownClassMapping } from '../../../model/packageableElements/mapping/V1_INTERNAL__UnknownClassMapping.js';
 
 enum V1_ClassMappingType {
   OPERATION = 'operation',
@@ -167,23 +168,7 @@ const V1_localMappingPropertyInfoModelSchema = createModelSchema(
   },
 );
 
-// ------------------------------------- M2M Mapping -------------------------------------
-
-const purePropertyMappingModelSchema = createModelSchema(
-  V1_PurePropertyMapping,
-  {
-    _type: usingConstantValueSchema(V1_PropertyMappingType.PURE),
-    enumMappingId: optional(primitive()),
-    explodeProperty: optional(primitive()),
-    localMappingProperty: usingModelSchema(
-      V1_localMappingPropertyInfoModelSchema,
-    ),
-    property: usingModelSchema(V1_propertyPointerModelSchema),
-    source: primitive(),
-    target: optional(primitive()),
-    transform: usingModelSchema(V1_rawLambdaModelSchema),
-  },
-);
+// ------------------------------------- Operation Mapping -------------------------------------
 
 const operationClassMappingModelSchema = createModelSchema(
   V1_OperationClassMapping,
@@ -212,7 +197,25 @@ const mergeOperationClassMappingModelSchema = createModelSchema(
   },
 );
 
-function V1_serializeM2MPropertyMapping(
+// ------------------------------------- Model-to-model Mapping -------------------------------------
+
+const purePropertyMappingModelSchema = createModelSchema(
+  V1_PurePropertyMapping,
+  {
+    _type: usingConstantValueSchema(V1_PropertyMappingType.PURE),
+    enumMappingId: optional(primitive()),
+    explodeProperty: optional(primitive()),
+    localMappingProperty: usingModelSchema(
+      V1_localMappingPropertyInfoModelSchema,
+    ),
+    property: usingModelSchema(V1_propertyPointerModelSchema),
+    source: primitive(),
+    target: optional(primitive()),
+    transform: usingModelSchema(V1_rawLambdaModelSchema),
+  },
+);
+
+function V1_serializePurePropertyMapping(
   protocol: V1_PurePropertyMapping,
 ): PlainObject<V1_PurePropertyMapping> | typeof SKIP {
   if (protocol instanceof V1_PurePropertyMapping) {
@@ -221,7 +224,7 @@ function V1_serializeM2MPropertyMapping(
   return SKIP;
 }
 
-function V1_deserializeM2MPropertyMapping(
+function V1_deserializePurePropertyMapping(
   json: PlainObject<V1_PurePropertyMapping>,
 ): V1_PurePropertyMapping | typeof SKIP {
   switch (json._type) {
@@ -242,8 +245,8 @@ const pureInstanceClassMappingModelSchema = createModelSchema(
     id: optional(primitive()),
     propertyMappings: list(
       custom(
-        (val) => V1_serializeM2MPropertyMapping(val),
-        (val) => V1_deserializeM2MPropertyMapping(val),
+        V1_serializePurePropertyMapping,
+        V1_deserializePurePropertyMapping,
       ),
     ),
     root: primitive(),
@@ -272,14 +275,14 @@ const rootRelationalClassMappingModelSchema = createModelSchema(
     mainTable: usingModelSchema(V1_tablePtrModelSchema),
     primaryKey: list(
       custom(
-        (val) => V1_serializeRelationalOperationElement(val),
-        (val) => V1_deserializeRelationalOperationElement(val),
+        V1_serializeRelationalOperationElement,
+        V1_deserializeRelationalOperationElement,
       ),
     ),
     propertyMappings: list(
       custom(
-        (val) => V1_serializeRelationalPropertyMapping(val),
-        (val) => V1_deserializeRelationalPropertyMapping(val),
+        V1_serializeRelationalPropertyMapping,
+        V1_deserializeRelationalPropertyMapping,
       ),
     ),
     root: optional(primitive()),
@@ -512,8 +515,8 @@ const embeddedFlatDataPropertyMappingModelSchema = createModelSchema(
     property: usingModelSchema(V1_propertyPointerModelSchema),
     propertyMappings: list(
       custom(
-        (val) => V1_serializeFlatDataPropertyMapping(val),
-        (val) => V1_deserializeFlatDataPropertyMapping(val),
+        V1_serializeFlatDataPropertyMapping,
+        V1_deserializeFlatDataPropertyMapping,
       ),
     ),
     root: primitive(),
@@ -557,8 +560,8 @@ const rootFlatDataCLassMappingModelSchema = createModelSchema(
     id: optional(primitive()),
     propertyMappings: list(
       custom(
-        (val) => V1_serializeFlatDataPropertyMapping(val),
-        (val) => V1_deserializeFlatDataPropertyMapping(val),
+        V1_serializeFlatDataPropertyMapping,
+        V1_deserializeFlatDataPropertyMapping,
       ),
     ),
     root: primitive(),
@@ -648,8 +651,8 @@ const aggregationAwareClassMappingModelSchema = (
     ),
     propertyMappings: list(
       custom(
-        (val) => V1_serializeAggregationAwarePropertyMapping(val),
-        (val) => V1_deserializeAggregationAwarePropertyMapping(val),
+        V1_serializeAggregationAwarePropertyMapping,
+        V1_deserializeAggregationAwarePropertyMapping,
       ),
     ),
     root: primitive(),
@@ -660,8 +663,10 @@ const aggregationAwareClassMappingModelSchema = (
 function V1_serializeClassMapping(
   value: V1_ClassMapping,
   plugins: PureProtocolProcessorPlugin[],
-): V1_ClassMapping {
-  if (value instanceof V1_MergeOperationClassMapping) {
+): PlainObject<V1_ClassMapping> {
+  if (value instanceof V1_INTERNAL__UnknownClassMapping) {
+    return value.content;
+  } else if (value instanceof V1_MergeOperationClassMapping) {
     return serialize(mergeOperationClassMappingModelSchema, value);
   } else if (value instanceof V1_OperationClassMapping) {
     return serialize(operationClassMappingModelSchema, value);
@@ -694,6 +699,15 @@ function V1_serializeClassMapping(
   );
 }
 
+const V1_INTERNAL__UnknownClassMappingModelSchema = createModelSchema(
+  V1_INTERNAL__UnknownClassMapping,
+  {
+    class: primitive(),
+    id: optional(primitive()),
+    root: primitive(),
+  },
+);
+
 function V1_deserializeClassMapping(
   json: PlainObject<V1_ClassMapping>,
   plugins: PureProtocolProcessorPlugin[],
@@ -729,9 +743,14 @@ function V1_deserializeClassMapping(
           return protocol;
         }
       }
-      throw new UnsupportedOperationError(
-        `Can't deserialize class mapping of type '${json._type}': no compatible deserializer available from plugins`,
+
+      // Fall back to create unknown stub if not supported
+      const protocol = deserialize(
+        V1_INTERNAL__UnknownClassMappingModelSchema,
+        json,
       );
+      protocol.content = json;
+      return protocol;
     }
   }
 }
@@ -846,16 +865,8 @@ const V1_deserializeTestAssert = (
 const V1_mappingTestModelLegacySchema = createModelSchema(
   V1_DEPRECATED__MappingTest,
   {
-    assert: custom(
-      (val) => V1_serializeTestAssert(val),
-      (val) => V1_deserializeTestAssert(val),
-    ),
-    inputData: list(
-      custom(
-        (val) => V1_serializeInputData(val),
-        (val) => V1_deserializeInputData(val),
-      ),
-    ),
+    assert: custom(V1_serializeTestAssert, V1_deserializeTestAssert),
+    inputData: list(custom(V1_serializeInputData, V1_deserializeInputData)),
     name: primitive(),
     query: usingModelSchema(V1_rawLambdaModelSchema),
   },
@@ -877,10 +888,7 @@ export const V1_mappingQueryTestModelSchema = createModelSchema(
   {
     _type: usingConstantValueSchema(ATOMIC_TEST_TYPE.Mapping_Query_Test),
     assertions: list(
-      custom(
-        (val) => V1_serializeTestAssertion(val),
-        (val) => V1_deserializeTestAssertion(val),
-      ),
+      custom(V1_serializeTestAssertion, V1_deserializeTestAssertion),
     ),
     id: primitive(),
     doc: optional(primitive()),
@@ -894,10 +902,7 @@ export const V1_mappingDataTestModelSchema = (
   createModelSchema(V1_MappingDataTest, {
     _type: usingConstantValueSchema(ATOMIC_TEST_TYPE.Mapping_Data_Test),
     assertions: list(
-      custom(
-        (val) => V1_serializeTestAssertion(val),
-        (val) => V1_deserializeTestAssertion(val),
-      ),
+      custom(V1_serializeTestAssertion, V1_deserializeTestAssertion),
     ),
     doc: optional(primitive()),
     id: primitive(),
@@ -948,7 +953,7 @@ enum V1_AssociationMappingType {
   FLAT_DATA = 'flatData',
 }
 
-const V1_serializeAssociationPropertMapping = (
+const V1_serializeAssociationPropertyMapping = (
   protocol: V1_PropertyMapping,
 ): PlainObject<V1_PropertyMapping> | typeof SKIP => {
   if (protocol instanceof V1_RelationalPropertyMapping) {
@@ -961,7 +966,7 @@ const V1_serializeAssociationPropertMapping = (
   return SKIP;
 };
 
-const V1_deserializeAssociationPropertMapping = (
+const V1_deserializeAssociationPropertyMapping = (
   json: PlainObject<V1_PropertyMapping>,
 ): V1_PropertyMapping | typeof SKIP => {
   switch (json._type) {
@@ -984,8 +989,8 @@ const relationalAssociationMappingModelschema = createModelSchema(
     id: optional(primitive()),
     propertyMappings: list(
       custom(
-        (val) => V1_serializeAssociationPropertMapping(val),
-        (val) => V1_deserializeAssociationPropertMapping(val),
+        V1_serializeAssociationPropertyMapping,
+        V1_deserializeAssociationPropertyMapping,
       ),
     ),
     stores: list(primitive()),
@@ -1000,8 +1005,8 @@ const flatDataAssociationMappingModelschema = createModelSchema(
     id: optional(primitive()),
     propertyMappings: list(
       custom(
-        (val) => V1_serializeAssociationPropertMapping(val),
-        (val) => V1_deserializeAssociationPropertMapping(val),
+        V1_serializeAssociationPropertyMapping,
+        V1_deserializeAssociationPropertyMapping,
       ),
     ),
     stores: list(primitive()),
@@ -1016,8 +1021,8 @@ const xStoreAssociationMappingModelschema = createModelSchema(
     id: optional(primitive()),
     propertyMappings: list(
       custom(
-        (val) => V1_serializeAssociationPropertMapping(val),
-        (val) => V1_deserializeAssociationPropertMapping(val),
+        V1_serializeAssociationPropertyMapping,
+        V1_deserializeAssociationPropertyMapping,
       ),
     ),
     stores: list(primitive()),

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

@@ -37,6 +37,7 @@ import {
 import { V1_MapperPostProcessor } from '../../../model/packageableElements/store/relational/connection/postprocessor/V1_MapperPostProcessor.js';
 import type { PureProtocolProcessorPlugin } from '../../../../PureProtocolProcessorPlugin.js';
 import type { STO_Relational_PureProtocolProcessorPlugin_Extension } from '../../../../extensions/STO_Relational_PureProtocolProcessorPlugin_Extension.js';
+import { V1_INTERNAL__UnknownPostProcessor } from '../../../model/packageableElements/store/relational/connection/postprocessor/V1_INTERNAL__UnknownPostProcessor.js';
 
 enum V1_MapperType {
   TABLE = 'table',
@@ -103,7 +104,9 @@ export const V1_serializePostProcessor = (
   value: V1_PostProcessor,
   plugins: PureProtocolProcessorPlugin[],
 ): PlainObject<V1_PostProcessor> => {
-  if (value instanceof V1_MapperPostProcessor) {
+  if (value instanceof V1_INTERNAL__UnknownPostProcessor) {
+    return value.content as PlainObject<V1_PostProcessor>;
+  } else if (value instanceof V1_MapperPostProcessor) {
     return serialize(V1_mapperPostProcessorModelSchema, value);
   }
   const extraPostprocessorProtocolSerializers = plugins.flatMap(
@@ -125,12 +128,12 @@ export const V1_serializePostProcessor = (
 };
 
 export const V1_deserializePostProcessor = (
-  value: PlainObject<V1_PostProcessor>,
+  json: PlainObject<V1_PostProcessor>,
   plugins: PureProtocolProcessorPlugin[],
 ): V1_PostProcessor => {
-  switch (value._type) {
+  switch (json._type) {
     case V1_PostProcessorType.MAPPER:
-      return deserialize(V1_mapperPostProcessorModelSchema, value);
+      return deserialize(V1_mapperPostProcessorModelSchema, json);
     default: {
       const extraPostprocessorProtocolDeserializers = plugins.flatMap(
         (plugin) =>
@@ -139,14 +142,16 @@ export const V1_deserializePostProcessor = (
           ).V1_getExtraConnectionPostProcessorProtocolDeserializers?.() ?? [],
       );
       for (const deserializer of extraPostprocessorProtocolDeserializers) {
-        const postProcessorProtocol = deserializer(value);
-        if (postProcessorProtocol) {
-          return postProcessorProtocol;
+        const protocol = deserializer(json);
+        if (protocol) {
+          return protocol;
         }
       }
-      throw new UnsupportedOperationError(
-        `Can't deserialize post-processor of type '${value._type}': no compatible deserializer available from plugins`,
-      );
+
+      // Fall back to create unknown stub if not supported
+      const protocol = new V1_INTERNAL__UnknownPostProcessor();
+      protocol.content = json;
+      return protocol;
     }
   }
 };

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

@@ -49,8 +49,8 @@ import {
 } from './V1_RuntimeSerializationHelper.js';
 import { V1_ServiceTest } from '../../../model/packageableElements/service/V1_ServiceTest.js';
 import {
-  V1_stereotypePtrSchema,
-  V1_taggedValueSchema,
+  V1_stereotypePtrModelSchema,
+  V1_taggedValueModelSchema,
 } from './V1_DomainSerializationHelper.js';
 import { V1_ConnectionTestData } from '../../../model/packageableElements/service/V1_ConnectionTestData.js';
 import {
@@ -309,10 +309,10 @@ export const V1_serviceModelSchema = (
     owners: list(primitive()),
     package: primitive(),
     pattern: primitive(),
-    stereotypes: customListWithSchema(V1_stereotypePtrSchema, {
+    stereotypes: customListWithSchema(V1_stereotypePtrModelSchema, {
       INTERNAL__forceReturnEmptyInTest: true,
     }),
-    taggedValues: customListWithSchema(V1_taggedValueSchema, {
+    taggedValues: customListWithSchema(V1_taggedValueModelSchema, {
       INTERNAL__forceReturnEmptyInTest: true,
     }),
     test: optionalCustom(

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

@@ -784,7 +784,7 @@ class V1_ValueSpecificationSerializer
   visit_INTERNAL__UnknownValueSpecfication(
     valueSpecification: V1_INTERNAL__UnknownValueSpecification,
   ): PlainObject<V1_ValueSpecification> {
-    return valueSpecification.content as PlainObject<V1_ValueSpecification>;
+    return valueSpecification.content;
   }
 
   visit_Variable(

package/src/graph-manager/protocol/pure/v1/transformation/pureProtocol/serializationHelpers/executionPlan/V1_ExecutionPlanSerializationHelper.ts

@@ -48,6 +48,8 @@ import {
   V1_deserializeDatabaseConnectionValue,
   V1_serializeDatabaseConnectionValue,
 } from '../V1_ConnectionSerializationHelper.js';
+import { V1_INTERNAL__UnknownResultType } from '../../../../model/executionPlan/results/V1_INTERNAL__UnknownResultType.js';
+import { V1_INTERNAL__UnknownExecutionNode } from '../../../../model/executionPlan/nodes/V1_INTERNAL__UnknownExecutionNode.js';
 
 // ---------------------------------------- Result Type ----------------------------------------
 
@@ -80,7 +82,9 @@ const TDSResultTypeModelSchema = createModelSchema(V1_TDSResultType, {
 const V1_serializeResultType = (
   protocol: V1_ResultType,
 ): PlainObject<V1_ResultType> => {
-  if (protocol instanceof V1_DataTypeResultType) {
+  if (protocol instanceof V1_INTERNAL__UnknownResultType) {
+    return protocol.content;
+  } else if (protocol instanceof V1_DataTypeResultType) {
     return serialize(dataTypeResultTypeModelSchema, protocol);
   } else if (protocol instanceof V1_TDSResultType) {
     return serialize(TDSResultTypeModelSchema, protocol);
@@ -99,10 +103,12 @@ const V1_deserializeResultType = (
       return deserialize(dataTypeResultTypeModelSchema, json);
     case V1_ExecutionResultTypeType.TDS:
       return deserialize(TDSResultTypeModelSchema, json);
-    default:
-      throw new UnsupportedOperationError(
-        `Can't deserialize execution result type of type '${json._type}'`,
-      );
+    default: {
+      // Fall back to create unknown stub if not supported
+      const protocol = new V1_INTERNAL__UnknownResultType();
+      protocol.content = json;
+      return protocol;
+    }
   }
 };
 
@@ -153,7 +159,9 @@ const SQLExecutionNodeModelSchema = createModelSchema(V1_SQLExecutionNode, {
 export function V1_serializeExecutionNode(
   protocol: V1_ResultType,
 ): PlainObject<V1_ResultType> {
-  if (protocol instanceof V1_RelationalTDSInstantiationExecutionNode) {
+  if (protocol instanceof V1_INTERNAL__UnknownExecutionNode) {
+    return protocol.content;
+  } else if (protocol instanceof V1_RelationalTDSInstantiationExecutionNode) {
     return serialize(
       relationalTDSInstantationExecutionNodeModelSchema,
       protocol,
@@ -167,6 +175,18 @@ export function V1_serializeExecutionNode(
   );
 }
 
+const V1_INTERNAL__UnknownExecutionNodeModelSchema = createModelSchema(
+  V1_INTERNAL__UnknownExecutionNode,
+  {
+    executionNodes: customList(
+      V1_serializeExecutionNode,
+      V1_deserializeExecutionNode,
+    ),
+    resultSizeRange: usingModelSchema(V1_multiplicityModelSchema),
+    resultType: custom(V1_serializeResultType, V1_deserializeResultType),
+  },
+);
+
 export function V1_deserializeExecutionNode(
   json: PlainObject<V1_ResultType>,
 ): V1_ResultType {
@@ -178,10 +198,15 @@ export function V1_deserializeExecutionNode(
       );
     case V1_ExecutionNodeType.SQL:
       return deserialize(SQLExecutionNodeModelSchema, json);
-    default:
-      throw new UnsupportedOperationError(
-        `Can't deserialize execution node of type '${json._type}'`,
+    default: {
+      // Fall back to create unknown stub if not supported
+      const protocol = deserialize(
+        V1_INTERNAL__UnknownExecutionNodeModelSchema,
+        json,
       );
+      protocol.content = json;
+      return protocol;
+    }
   }
 }