@finos/legend-graph 5.0.0 → 6.0.0

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

@@ -21,6 +21,8 @@ import {
   custom,
   list,
   serialize,
+  raw,
+  type ModelSchema,
 } from 'serializr';
 import {
   type PlainObject,
@@ -29,6 +31,7 @@ import {
   UnsupportedOperationError,
   serializeArray,
   usingModelSchema,
+  optionalCustom,
 } from '@finos/legend-shared';
 import {
   type V1_ServiceExecution,
@@ -48,18 +51,38 @@ import {
   V1_runtimePointerModelSchema,
   V1_RuntimeType,
 } from './V1_RuntimeSerializationHelper';
-import {
-  type V1_ServiceTest,
-  V1_KeyedSingleExecutionTest,
-  V1_MultiExecutionTest,
-  V1_SingleExecutionTest,
-  V1_TestContainer,
-} from '../../../model/packageableElements/service/V1_ServiceTest';
+import { V1_ServiceTest } from '../../../model/packageableElements/service/V1_ServiceTest';
 import {
   V1_stereotypePtrSchema,
   V1_taggedValueSchema,
 } from './V1_DomainSerializationHelper';
-import type { V1_StereotypePtr } from '../../../model/packageableElements/domain/V1_StereotypePtr';
+import { V1_ConnectionTestData } from '../../../model/packageableElements/service/V1_ConnectionTestData';
+import {
+  V1_deserializeEmbeddedDataType,
+  V1_serializeEmbeddedDataType,
+} from './V1_DataElementSerializationHelper';
+import { V1_ParameterValue } from '../../../model/packageableElements/service/V1_ParameterValue';
+import { V1_TestData } from '../../../model/packageableElements/service/V1_TestData';
+import {
+  V1_AtomicTestType,
+  V1_deserializeAtomicTest,
+  V1_deserializeTestAssertion,
+  V1_deserializeTestSuite,
+  V1_serializeAtomicTest,
+  V1_serializeTestAssertion,
+  V1_serializeTestSuite,
+  V1_TestSuiteType,
+} from './V1_TestSerializationHelper';
+import { V1_ServiceTestSuite } from '../../../model/packageableElements/service/V1_ServiceTestSuite';
+import {
+  type V1_DEPRECATED__ServiceTest,
+  V1_DEPRECATED__KeyedSingleExecutionTest,
+  V1_DEPRECATED__MultiExecutionTest,
+  V1_DEPRECATED__SingleExecutionTest,
+  V1_DEPRECATED__TestContainer,
+} from '../../../model/packageableElements/service/V1_DEPRECATED__ServiceTest';
+import type { PureProtocolProcessorPlugin } from '../../../../PureProtocolProcessorPlugin';
+import type { V1_TestSuite } from '../../../model/test/V1_TestSuite';
 
 export const V1_SERVICE_ELEMENT_PROTOCOL_TYPE = 'service';
 
@@ -73,6 +96,78 @@ enum V1_ServiceExecutionType {
   PURE_MULTI_EXECUTION = 'pureMultiExecution',
 }
 
+export const V1_connectionTestDataModelSchema = (
+  plugins: PureProtocolProcessorPlugin[],
+): ModelSchema<V1_ConnectionTestData> =>
+  createModelSchema(V1_ConnectionTestData, {
+    data: custom(
+      (val) => V1_serializeEmbeddedDataType(val, plugins),
+      (val) => V1_deserializeEmbeddedDataType(val, plugins),
+    ),
+    id: primitive(),
+  });
+
+export const V1_parameterValueModelSchema = createModelSchema(
+  V1_ParameterValue,
+  {
+    name: primitive(),
+    value: raw(),
+  },
+);
+
+export const V1_testDataModelSchema = (
+  plugins: PureProtocolProcessorPlugin[],
+): ModelSchema<V1_TestData> =>
+  createModelSchema(V1_TestData, {
+    connectionsTestData: list(
+      usingModelSchema(V1_connectionTestDataModelSchema(plugins)),
+    ),
+  });
+
+export const V1_serviceTestModelSchema = createModelSchema(V1_ServiceTest, {
+  _type: usingConstantValueSchema(V1_AtomicTestType.SERVICE_TEST),
+  assertions: list(
+    custom(
+      (val) => V1_serializeTestAssertion(val),
+      (val) => V1_deserializeTestAssertion(val),
+    ),
+  ),
+  id: primitive(),
+  parameters: custom(
+    (values) =>
+      serializeArray(
+        values,
+        (value) => serialize(V1_parameterValueModelSchema, value),
+        {
+          skipIfEmpty: true,
+        },
+      ),
+    (values) =>
+      deserializeArray(
+        values,
+        (v) => deserialize(V1_parameterValueModelSchema, v),
+        {
+          skipIfEmpty: false,
+        },
+      ),
+  ),
+});
+
+export const V1_serviceTestSuiteModelSchema = (
+  plugins: PureProtocolProcessorPlugin[],
+): ModelSchema<V1_ServiceTestSuite> =>
+  createModelSchema(V1_ServiceTestSuite, {
+    _type: usingConstantValueSchema(V1_TestSuiteType.SERVICE_TEST_SUITE),
+    id: primitive(),
+    testData: usingModelSchema(V1_testDataModelSchema(plugins)),
+    tests: list(
+      custom(
+        (val) => V1_serializeAtomicTest(val),
+        (val) => V1_deserializeAtomicTest(val),
+      ),
+    ),
+  });
+
 const V1_serializeRuntimeValue = (
   protocol: V1_Runtime,
 ): PlainObject<V1_Runtime> => {
@@ -172,16 +267,26 @@ const V1_deserializeServiceExecution = (
   }
 };
 
-const testContainerModelSchema = createModelSchema(V1_TestContainer, {
-  assert: usingModelSchema(V1_rawLambdaModelSchema),
-  parametersValues: custom(
-    (values) => serializeArray(values, (value) => value, true),
-    (values) => deserializeArray(values, (v) => v, false),
-  ),
-});
+const testContainerModelSchema = createModelSchema(
+  V1_DEPRECATED__TestContainer,
+  {
+    assert: usingModelSchema(V1_rawLambdaModelSchema),
+    parametersValues: custom(
+      (values) =>
+        serializeArray(values, (value) => value, {
+          skipIfEmpty: true,
+          INTERNAL__forceReturnEmptyInTest: true,
+        }),
+      (values) =>
+        deserializeArray(values, (v) => v, {
+          skipIfEmpty: false,
+        }),
+    ),
+  },
+);
 
 const singleExecutionTestModelSchema = createModelSchema(
-  V1_SingleExecutionTest,
+  V1_DEPRECATED__SingleExecutionTest,
   {
     _type: usingConstantValueSchema(V1_ServiceTestType.SINGLE_EXECUTION_TEST),
     asserts: list(usingModelSchema(testContainerModelSchema)),
@@ -190,7 +295,7 @@ const singleExecutionTestModelSchema = createModelSchema(
 );
 
 const keyedSingleExecutionTestModelSchema = createModelSchema(
-  V1_KeyedSingleExecutionTest,
+  V1_DEPRECATED__KeyedSingleExecutionTest,
   {
     asserts: list(usingModelSchema(testContainerModelSchema)),
     data: primitive(),
@@ -198,25 +303,28 @@ const keyedSingleExecutionTestModelSchema = createModelSchema(
   },
 );
 
-const multiExecutionTestModelSchema = createModelSchema(V1_MultiExecutionTest, {
-  _type: usingConstantValueSchema(V1_ServiceTestType.MULTI_EXECUTION_TEST),
-  tests: list(usingModelSchema(keyedSingleExecutionTestModelSchema)),
-});
+const multiExecutionTestModelSchema = createModelSchema(
+  V1_DEPRECATED__MultiExecutionTest,
+  {
+    _type: usingConstantValueSchema(V1_ServiceTestType.MULTI_EXECUTION_TEST),
+    tests: list(usingModelSchema(keyedSingleExecutionTestModelSchema)),
+  },
+);
 
-const V1_serializeServiceTest = (
-  protocol: V1_ServiceTest,
-): PlainObject<V1_ServiceTest> => {
-  if (protocol instanceof V1_SingleExecutionTest) {
+const V1_serializeLegacyServiceTest = (
+  protocol: V1_DEPRECATED__ServiceTest,
+): PlainObject<V1_DEPRECATED__ServiceTest> => {
+  if (protocol instanceof V1_DEPRECATED__SingleExecutionTest) {
     return serialize(singleExecutionTestModelSchema, protocol);
-  } else if (protocol instanceof V1_MultiExecutionTest) {
+  } else if (protocol instanceof V1_DEPRECATED__MultiExecutionTest) {
     return serialize(multiExecutionTestModelSchema, protocol);
   }
   throw new UnsupportedOperationError(`Can't serialize service test`, protocol);
 };
 
-const V1_deserializeServiceTest = (
-  json: PlainObject<V1_ServiceTest>,
-): V1_ServiceTest => {
+const V1_deserializeLegacyServiceTest = (
+  json: PlainObject<V1_DEPRECATED__ServiceTest>,
+): V1_DEPRECATED__ServiceTest => {
   switch (json._type) {
     case V1_ServiceTestType.SINGLE_EXECUTION_TEST:
       return deserialize(singleExecutionTestModelSchema, json);
@@ -229,48 +337,72 @@ const V1_deserializeServiceTest = (
   }
 };
 
-export const V1_servicedModelSchema = createModelSchema(V1_Service, {
-  _type: usingConstantValueSchema(V1_SERVICE_ELEMENT_PROTOCOL_TYPE),
-  autoActivateUpdates: primitive(),
-  documentation: primitive(),
-  execution: custom(
-    (val) => V1_serializeServiceExecution(val),
-    (val) => V1_deserializeServiceExecution(val),
-  ),
-  name: primitive(),
-  owners: list(primitive()),
-  package: primitive(),
-  pattern: primitive(),
-  stereotypes: custom(
-    (values) =>
-      serializeArray(
-        values,
-        (value) => serialize(V1_stereotypePtrSchema, value),
-        true,
-      ),
-    (values) =>
-      deserializeArray(
-        values,
-        (v: V1_StereotypePtr) => deserialize(V1_stereotypePtrSchema, v),
-        false,
-      ),
-  ),
-  taggedValues: custom(
-    (values) =>
-      serializeArray(
-        values,
-        (value) => serialize(V1_taggedValueSchema, value),
-        true,
-      ),
-    (values) =>
-      deserializeArray(
-        values,
-        (v: V1_StereotypePtr) => deserialize(V1_taggedValueSchema, v),
-        false,
-      ),
-  ),
-  test: custom(
-    (val) => V1_serializeServiceTest(val),
-    (val) => V1_deserializeServiceTest(val),
-  ),
-});
+export const V1_serviceModelSchema = (
+  plugins: PureProtocolProcessorPlugin[],
+): ModelSchema<V1_Service> =>
+  createModelSchema(V1_Service, {
+    _type: usingConstantValueSchema(V1_SERVICE_ELEMENT_PROTOCOL_TYPE),
+    autoActivateUpdates: primitive(),
+    documentation: primitive(),
+    execution: custom(
+      (val) => V1_serializeServiceExecution(val),
+      (val) => V1_deserializeServiceExecution(val),
+    ),
+    name: primitive(),
+    owners: list(primitive()),
+    package: primitive(),
+    pattern: primitive(),
+    stereotypes: custom(
+      (values) =>
+        serializeArray(
+          values,
+          (value) => serialize(V1_stereotypePtrSchema, value),
+          {
+            skipIfEmpty: true,
+            INTERNAL__forceReturnEmptyInTest: true,
+          },
+        ),
+      (values) =>
+        deserializeArray(
+          values,
+          (v) => deserialize(V1_stereotypePtrSchema, v),
+          {
+            skipIfEmpty: false,
+          },
+        ),
+    ),
+    taggedValues: custom(
+      (values) =>
+        serializeArray(
+          values,
+          (value) => serialize(V1_taggedValueSchema, value),
+          {
+            skipIfEmpty: true,
+            INTERNAL__forceReturnEmptyInTest: true,
+          },
+        ),
+      (values) =>
+        deserializeArray(values, (v) => deserialize(V1_taggedValueSchema, v), {
+          skipIfEmpty: false,
+        }),
+    ),
+    test: optionalCustom(
+      V1_serializeLegacyServiceTest,
+      V1_deserializeLegacyServiceTest,
+    ),
+    testSuites: custom(
+      (values) =>
+        serializeArray(
+          values,
+          (value: V1_TestSuite) => V1_serializeTestSuite(value, plugins),
+          {
+            skipIfEmpty: true,
+            INTERNAL__forceReturnEmptyInTest: true,
+          },
+        ),
+      (values) =>
+        deserializeArray(values, (v) => V1_deserializeTestSuite(v, plugins), {
+          skipIfEmpty: false,
+        }),
+    ),
+  });

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

@@ -265,8 +265,15 @@ function V1_flatDataSectionDeserializer(value: {
 export const V1_flatDataModelSchema = createModelSchema(V1_FlatData, {
   _type: usingConstantValueSchema(V1_FLAT_DATA_ELEMENT_PROTOCOL_TYPE),
   includedStores: custom(
-    (values) => serializeArray(values, (value) => value, true),
-    (values) => deserializeArray(values, (value) => value, false),
+    (values) =>
+      serializeArray(values, (value: string) => value, {
+        skipIfEmpty: true,
+        INTERNAL__forceReturnEmptyInTest: true,
+      }),
+    (values) =>
+      deserializeArray(values, (value) => value, {
+        skipIfEmpty: false,
+      }),
   ),
   name: primitive(),
   package: primitive(),

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

@@ -0,0 +1,247 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+  type PlainObject,
+  UnsupportedOperationError,
+  usingConstantValueSchema,
+  usingModelSchema,
+} from '@finos/legend-shared';
+import {
+  createModelSchema,
+  custom,
+  deserialize,
+  list,
+  primitive,
+  serialize,
+} from 'serializr';
+import type { PureProtocolProcessorPlugin } from '../../../../PureProtocolProcessorPlugin';
+import { V1_ServiceTest } from '../../../model/packageableElements/service/V1_ServiceTest';
+import { V1_ServiceTestSuite } from '../../../model/packageableElements/service/V1_ServiceTestSuite';
+import { V1_AssertFail } from '../../../model/test/assertion/status/V1_AssertFail';
+import type { V1_AssertionStatus } from '../../../model/test/assertion/status/V1_AssertionStatus';
+import { V1_AssertPass } from '../../../model/test/assertion/status/V1_AssertPass';
+import { V1_EqualToJsonAssertFail } from '../../../model/test/assertion/status/V1_EqualToJsonAssertFail';
+import { V1_EqualTo } from '../../../model/test/assertion/V1_EqualTo';
+import { V1_EqualToJson } from '../../../model/test/assertion/V1_EqualToJson';
+import type { V1_TestAssertion } from '../../../model/test/assertion/V1_TestAssertion';
+import { V1_TestError } from '../../../model/test/result/V1_TestError';
+import { V1_TestFailed } from '../../../model/test/result/V1_TestFailed';
+import { V1_TestPassed } from '../../../model/test/result/V1_TestPassed';
+import { V1_TestResult } from '../../../model/test/result/V1_TestResult';
+import type { V1_AtomicTest } from '../../../model/test/V1_AtomicTest';
+import { V1_AtomicTestId } from '../../../model/test/V1_AtomicTestId';
+import type { V1_TestSuite } from '../../../model/test/V1_TestSuite';
+import { V1_externalFormatDataModelSchema } from './V1_DataElementSerializationHelper';
+import {
+  V1_serviceTestModelSchema,
+  V1_serviceTestSuiteModelSchema,
+} from './V1_ServiceSerializationHelper';
+
+enum V1_AssertionStatusType {
+  ASSERT_FAIL = 'assertFail',
+  ASSERT_PASS = 'assertPass',
+  EQUAL_TO_JSON_ASSERT_FAIL = 'equalToJsonAssertFail',
+}
+
+export enum V1_AtomicTestType {
+  SERVICE_TEST = 'serviceTest',
+}
+
+enum V1_TestAssertionType {
+  EQUAL_TO = 'equalTo',
+  EQUAL_TO_JSON = 'equalToJson',
+}
+
+export enum V1_TestSuiteType {
+  SERVICE_TEST_SUITE = 'serviceTestSuite',
+}
+
+export const V1_atomicTestIdModelSchema = createModelSchema(V1_AtomicTestId, {
+  atomicTestId: primitive(),
+  key: primitive(),
+});
+
+export const V1_assertFailModelSchema = createModelSchema(V1_AssertFail, {
+  _type: usingConstantValueSchema(V1_AssertionStatusType.ASSERT_FAIL),
+  id: primitive(),
+  message: primitive(),
+});
+
+export const V1_assertPassModelSchema = createModelSchema(V1_AssertPass, {
+  _type: usingConstantValueSchema(V1_AssertionStatusType.ASSERT_PASS),
+  id: primitive(),
+});
+
+export const V1_equalToJsonAssertFailModelSchema = createModelSchema(
+  V1_EqualToJsonAssertFail,
+  {
+    _type: usingConstantValueSchema(
+      V1_AssertionStatusType.EQUAL_TO_JSON_ASSERT_FAIL,
+    ),
+    actual: primitive(),
+    expected: primitive(),
+    id: primitive(),
+    message: primitive(),
+  },
+);
+
+const V1_serializeAssertionStatus = (
+  protocol: V1_AssertionStatus,
+): PlainObject<V1_AssertionStatus> => {
+  if (protocol instanceof V1_EqualToJsonAssertFail) {
+    return serialize(V1_equalToJsonAssertFailModelSchema, protocol);
+  } else if (protocol instanceof V1_AssertFail) {
+    return serialize(V1_assertFailModelSchema, protocol);
+  } else if (protocol instanceof V1_AssertPass) {
+    return serialize(V1_assertPassModelSchema, protocol);
+  }
+  throw new UnsupportedOperationError(
+    `Can't serialize assertion status`,
+    protocol,
+  );
+};
+
+const V1_deserializeAssertionStatus = (
+  json: PlainObject<V1_AssertionStatus>,
+): V1_AssertionStatus => {
+  switch (json._type) {
+    case V1_AssertionStatusType.ASSERT_FAIL:
+      return deserialize(V1_assertFailModelSchema, json);
+    case V1_AssertionStatusType.ASSERT_PASS:
+      return deserialize(V1_assertPassModelSchema, json);
+    case V1_AssertionStatusType.EQUAL_TO_JSON_ASSERT_FAIL:
+      return deserialize(V1_equalToJsonAssertFailModelSchema, json);
+    default:
+      throw new UnsupportedOperationError(
+        `Can't deserialize assertion status of type '${json._type}'`,
+      );
+  }
+};
+
+export const V1_equalToModelSchema = createModelSchema(V1_EqualTo, {
+  _type: usingConstantValueSchema(V1_TestAssertionType.EQUAL_TO),
+  expected: primitive(),
+  id: primitive(),
+});
+
+export const V1_equalToJsonModelSchema = createModelSchema(V1_EqualToJson, {
+  _type: usingConstantValueSchema(V1_TestAssertionType.EQUAL_TO_JSON),
+  expected: usingModelSchema(V1_externalFormatDataModelSchema),
+  id: primitive(),
+});
+
+export const V1_testErrorModelSchema = createModelSchema(V1_TestError, {
+  atomicTestId: usingModelSchema(V1_atomicTestIdModelSchema),
+  error: primitive(),
+  testable: primitive(),
+});
+
+export const V1_testFailedModelSchema = createModelSchema(V1_TestFailed, {
+  assertStatuses: list(
+    custom(
+      (val) => V1_serializeAssertionStatus(val),
+      (val) => V1_deserializeAssertionStatus(val),
+    ),
+  ),
+  atomicTestId: usingModelSchema(V1_atomicTestIdModelSchema),
+  testable: primitive(),
+});
+
+export const V1_testPassedModelSchema = createModelSchema(V1_TestPassed, {
+  atomicTestId: usingModelSchema(V1_atomicTestIdModelSchema),
+  testable: primitive(),
+});
+
+export const V1_testResultModelSchema = createModelSchema(V1_TestResult, {
+  atomicTestId: usingModelSchema(V1_atomicTestIdModelSchema),
+  testable: primitive(),
+});
+
+export const V1_serializeAtomicTest = (
+  protocol: V1_AtomicTest,
+): PlainObject<V1_AtomicTest> => {
+  if (protocol instanceof V1_ServiceTest) {
+    return serialize(V1_serviceTestModelSchema, protocol);
+  }
+  throw new UnsupportedOperationError(`Can't serialize atomic test`, protocol);
+};
+
+export const V1_deserializeAtomicTest = (
+  json: PlainObject<V1_AtomicTest>,
+): V1_AtomicTest => {
+  switch (json._type) {
+    case V1_AtomicTestType.SERVICE_TEST:
+      return deserialize(V1_serviceTestModelSchema, json);
+    default:
+      throw new UnsupportedOperationError(
+        `Can't deserialize atomic test of type '${json._type}'`,
+      );
+  }
+};
+
+export const V1_serializeTestAssertion = (
+  protocol: V1_TestAssertion,
+): PlainObject<V1_TestAssertion> => {
+  if (protocol instanceof V1_EqualTo) {
+    return serialize(V1_equalToModelSchema, protocol);
+  } else if (protocol instanceof V1_EqualToJson) {
+    return serialize(V1_equalToJsonModelSchema, protocol);
+  }
+  throw new UnsupportedOperationError(
+    `Can't serialize test assertion`,
+    protocol,
+  );
+};
+
+export const V1_deserializeTestAssertion = (
+  json: PlainObject<V1_TestAssertion>,
+): V1_TestAssertion => {
+  switch (json._type) {
+    case V1_TestAssertionType.EQUAL_TO:
+      return deserialize(V1_equalToModelSchema, json);
+    case V1_TestAssertionType.EQUAL_TO_JSON:
+      return deserialize(V1_equalToJsonModelSchema, json);
+    default:
+      throw new UnsupportedOperationError(
+        `Can't deserialize test assertion of type '${json._type}'`,
+      );
+  }
+};
+
+export const V1_serializeTestSuite = (
+  protocol: V1_TestSuite,
+  plugins: PureProtocolProcessorPlugin[],
+): PlainObject<V1_TestSuite> => {
+  if (protocol instanceof V1_ServiceTestSuite) {
+    return serialize(V1_serviceTestSuiteModelSchema(plugins), protocol);
+  }
+  throw new UnsupportedOperationError(`Can't serialize test suite`, protocol);
+};
+
+export const V1_deserializeTestSuite = (
+  json: PlainObject<V1_TestSuite>,
+  plugins: PureProtocolProcessorPlugin[],
+): V1_TestSuite => {
+  switch (json._type) {
+    case V1_TestSuiteType.SERVICE_TEST_SUITE:
+      return deserialize(V1_serviceTestSuiteModelSchema(plugins), json);
+    default:
+      throw new UnsupportedOperationError(
+        `Can't deserialize test suite of type '${json._type}'`,
+      );
+  }
+};

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

@@ -78,7 +78,7 @@ import type { V1_GraphFetchTree } from '../../../model/valueSpecification/raw/gr
 import { V1_PackageableElementPtr } from '../../../model/valueSpecification/raw/V1_PackageableElementPtr';
 import { V1_HackedClass } from '../../../model/valueSpecification/raw/V1_HackedClass';
 import { V1_HackedUnit } from '../../../model/valueSpecification/raw/V1_HackedUnit';
-import type { V1_INTERNAL__UnknownValueSpecfication } from '../../../model/valueSpecification/V1_INTERNAL__UnknownValueSpecfication';
+import type { V1_INTERNAL__UnknownValueSpecification } from '../../../model/valueSpecification/V1_INTERNAL__UnknownValueSpecfication';
 import { V1_EngineRuntime } from '../../../model/packageableElements/runtime/V1_Runtime';
 
 enum V1_PathElementType {
@@ -496,7 +496,7 @@ class V1_ValueSpecificationSerializer
   implements V1_ValueSpecificationVisitor<PlainObject<V1_ValueSpecification>>
 {
   visit_INTERNAL__UnknownValueSpecfication(
-    valueSpecification: V1_INTERNAL__UnknownValueSpecfication,
+    valueSpecification: V1_INTERNAL__UnknownValueSpecification,
   ): PlainObject<V1_ValueSpecification> {
     return valueSpecification.content as PlainObject<V1_ValueSpecification>;
   }

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

@@ -28,7 +28,7 @@ import {
   optionalCustom,
   deserializeArray,
   serializeArray,
-  deseralizeMap,
+  deserializeMap,
   serializeMap,
   usingModelSchema,
   usingConstantValueSchema,
@@ -65,8 +65,8 @@ const dataTypeResultTypeModelSchema = createModelSchema(V1_DataTypeResultType, {
 const TDSColumnModelSchema = createModelSchema(V1_TDSColumn, {
   doc: optional(primitive()),
   enumMapping: optionalCustom(
-    (val: Map<string, unknown>) => serializeMap(val),
-    deseralizeMap,
+    (val) => serializeMap(val, (v) => v),
+    (val) => deserializeMap(val, (v) => v),
   ),
   name: primitive(),
   relationalType: optional(primitive()),
@@ -147,13 +147,18 @@ const SQLExecutionNodeModelSchema = createModelSchema(V1_SQLExecutionNode, {
   ),
   executionNodes: custom(
     (values) =>
-      serializeArray(values, (value) => V1_serializeExecutionNode(value), true),
-    (values) =>
-      deserializeArray(
+      serializeArray(
         values,
-        (value) => V1_deserializeExecutionNode(value),
-        false,
+        (value: V1_ResultType) => V1_serializeExecutionNode(value),
+        {
+          skipIfEmpty: true,
+          INTERNAL__forceReturnEmptyInTest: true,
+        },
       ),
+    (values) =>
+      deserializeArray(values, (value) => V1_deserializeExecutionNode(value), {
+        skipIfEmpty: false,
+      }),
   ),
   onConnectionCloseCommitQuery: optional(primitive()),
   onConnectionCloseRollbackQuery: optional(primitive()),