@finos/legend-graph 4.0.3 → 6.0.1

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

@@ -0,0 +1,184 @@
+/**
+ * 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 { guaranteeType, UnsupportedOperationError } from '@finos/legend-shared';
+import { ExternalFormatData } from '../../../../../../../metamodels/pure/data/EmbeddedData';
+import { EqualTo } from '../../../../../../../metamodels/pure/test/assertion/EqualTo';
+import { EqualToJson } from '../../../../../../../metamodels/pure/test/assertion/EqualToJson';
+import { AssertFail } from '../../../../../../../metamodels/pure/test/assertion/status/AssertFail';
+import type { AssertionStatus } from '../../../../../../../metamodels/pure/test/assertion/status/AssertionStatus';
+import { AssertPass } from '../../../../../../../metamodels/pure/test/assertion/status/AssertPass';
+import { EqualToJsonAssertFail } from '../../../../../../../metamodels/pure/test/assertion/status/EqualToJsonAssertFail';
+import type { TestAssertion } from '../../../../../../../metamodels/pure/test/assertion/TestAssertion';
+import { AtomicTestId } from '../../../../../../../metamodels/pure/test/result/AtomicTestId';
+import { TestError } from '../../../../../../../metamodels/pure/test/result/TestError';
+import { TestFailed } from '../../../../../../../metamodels/pure/test/result/TestFailed';
+import { TestPassed } from '../../../../../../../metamodels/pure/test/result/TestPassed';
+import { TestResult } from '../../../../../../../metamodels/pure/test/result/TestResult';
+import type {
+  AtomicTest,
+  TestSuite,
+} from '../../../../../../../metamodels/pure/test/Test';
+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 type { V1_TestError } from '../../../../model/test/result/V1_TestError';
+import type { V1_TestFailed } from '../../../../model/test/result/V1_TestFailed';
+import type { V1_TestPassed } from '../../../../model/test/result/V1_TestPassed';
+import type { V1_TestResult } from '../../../../model/test/result/V1_TestResult';
+import type { V1_AtomicTest } from '../../../../model/test/V1_AtomicTest';
+import type { V1_AtomicTestId } from '../../../../model/test/V1_AtomicTestId';
+import type { V1_TestSuite } from '../../../../model/test/V1_TestSuite';
+import type { V1_GraphBuilderContext } from '../V1_GraphBuilderContext';
+import { V1_ProtocolToMetaModelEmbeddedDataBuilder } from './V1_DataElementBuilderHelper';
+import {
+  V1_buildServiceTest,
+  V1_buildServiceTestSuite,
+} from './V1_ServiceBuilderHelper';
+
+const buildAtomicTestId = (element: V1_AtomicTestId): AtomicTestId => {
+  const atomicTestId = new AtomicTestId();
+  atomicTestId.atomicTestId = element.atomicTestId;
+  atomicTestId.testSuiteId = element.testSuiteId;
+  return atomicTestId;
+};
+
+const buildAssertFail = (element: V1_AssertFail): AssertFail => {
+  const assertFail = new AssertFail();
+  assertFail.id = element.id;
+  assertFail.message = element.message;
+  return assertFail;
+};
+
+const buildAssertPass = (element: V1_AssertPass): AssertPass => {
+  const assertPass = new AssertPass();
+  assertPass.id = element.id;
+  return assertPass;
+};
+
+const buildEqualToJsonAssertFail = (
+  element: V1_EqualToJsonAssertFail,
+): EqualToJsonAssertFail => {
+  const equalToJsonAssertFail = new EqualToJsonAssertFail();
+  equalToJsonAssertFail.id = element.id;
+  equalToJsonAssertFail.message = element.message;
+  equalToJsonAssertFail.actual = element.actual;
+  equalToJsonAssertFail.expected = element.expected;
+  return equalToJsonAssertFail;
+};
+
+const buildAssertionStatus = (value: V1_AssertionStatus): AssertionStatus => {
+  if (value instanceof V1_EqualToJsonAssertFail) {
+    return buildEqualToJsonAssertFail(value);
+  } else if (value instanceof V1_AssertFail) {
+    return buildAssertFail(value);
+  } else if (value instanceof V1_AssertPass) {
+    return buildAssertPass(value);
+  }
+  throw new UnsupportedOperationError(`Can't build assertion status`, value);
+};
+
+const buildEqualTo = (element: V1_EqualTo): EqualTo => {
+  const equalTo = new EqualTo();
+  equalTo.id = element.id;
+  equalTo.expected = element.expected;
+  return equalTo;
+};
+
+const buildEqualToJson = (
+  element: V1_EqualToJson,
+  context: V1_GraphBuilderContext,
+): EqualToJson => {
+  const equalToJson = new EqualToJson();
+  equalToJson.id = element.id;
+  equalToJson.expected = guaranteeType(
+    element.expected.accept_EmbeddedDataVisitor(
+      new V1_ProtocolToMetaModelEmbeddedDataBuilder(context),
+    ),
+    ExternalFormatData,
+  );
+  return equalToJson;
+};
+
+export const V1_buildTestError = (element: V1_TestError): TestError => {
+  const testError = new TestError();
+  testError.testable = element.testable;
+  testError.error = element.error;
+  testError.atomicTestId = buildAtomicTestId(element.atomicTestId);
+  return testError;
+};
+
+export const V1_buildTestFailed = (element: V1_TestFailed): TestFailed => {
+  const testFailed = new TestFailed();
+  testFailed.testable = element.testable;
+  testFailed.atomicTestId = buildAtomicTestId(element.atomicTestId);
+  testFailed.assertStatuses = element.assertStatuses.map((assertStatus) =>
+    buildAssertionStatus(assertStatus),
+  );
+  return testFailed;
+};
+
+export const V1_buildTestPassed = (element: V1_TestPassed): TestPassed => {
+  const testPassed = new TestPassed();
+  testPassed.testable = element.testable;
+  testPassed.atomicTestId = buildAtomicTestId(element.atomicTestId);
+  return testPassed;
+};
+
+export const V1_buildTestResult = (element: V1_TestResult): TestResult => {
+  const testResult = new TestResult();
+  testResult.testable = element.testable;
+  testResult.atomicTestId = buildAtomicTestId(element.atomicTestId);
+  return testResult;
+};
+
+export const V1_buildAtomicTest = (
+  value: V1_AtomicTest,
+  context: V1_GraphBuilderContext,
+): AtomicTest => {
+  if (value instanceof V1_ServiceTest) {
+    return V1_buildServiceTest(value, context);
+  }
+  throw new UnsupportedOperationError(`Can't build atomic test`, value);
+};
+
+export const V1_buildTestAssertion = (
+  value: V1_TestAssertion,
+  context: V1_GraphBuilderContext,
+): TestAssertion => {
+  if (value instanceof V1_EqualTo) {
+    return buildEqualTo(value);
+  } else if (value instanceof V1_EqualToJson) {
+    return buildEqualToJson(value, context);
+  }
+  throw new UnsupportedOperationError(`Can't build test assertion`, value);
+};
+
+export const V1_buildTestSuite = (
+  value: V1_TestSuite,
+  context: V1_GraphBuilderContext,
+): TestSuite => {
+  if (value instanceof V1_ServiceTestSuite) {
+    return V1_buildServiceTestSuite(value, context);
+  }
+  throw new UnsupportedOperationError(`Can't build test suite`, value);
+};

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

@@ -118,7 +118,7 @@ import { EnumValueExplicitReference } from '../../../../../../../metamodels/pure
 import type { V1_PackageableElementPtr } from '../../../../model/valueSpecification/raw/V1_PackageableElementPtr';
 import type { V1_HackedClass } from '../../../../model/valueSpecification/raw/V1_HackedClass';
 import type { 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 { INTERNAL__UnknownValueSpecification } from '../../../../../../../metamodels/pure/valueSpecification/INTERNAL__UnknownValueSpecification';
 import { GraphBuilderError } from '../../../../../../../../graphManager/GraphManagerUtils';
 
@@ -154,7 +154,7 @@ export class V1_ValueSpecificationBuilder
   }
 
   visit_INTERNAL__UnknownValueSpecfication(
-    valueSpecification: V1_INTERNAL__UnknownValueSpecfication,
+    valueSpecification: V1_INTERNAL__UnknownValueSpecification,
   ): ValueSpecification {
     const metamodel = new INTERNAL__UnknownValueSpecification(
       valueSpecification.content,

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

@@ -60,7 +60,7 @@ import type { V1_TdsOlapRank } from '../../../../model/valueSpecification/raw/V1
 import type { V1_TDSSortInformation } from '../../../../model/valueSpecification/raw/V1_TDSSortInformation';
 import type { V1_UnitInstance } from '../../../../model/valueSpecification/raw/V1_UnitInstance';
 import type { V1_UnitType } from '../../../../model/valueSpecification/raw/V1_UnitType';
-import type { V1_INTERNAL__UnknownValueSpecfication } from '../../../../model/valueSpecification/V1_INTERNAL__UnknownValueSpecfication';
+import type { V1_INTERNAL__UnknownValueSpecification } from '../../../../model/valueSpecification/V1_INTERNAL__UnknownValueSpecfication';
 import type {
   V1_ValueSpecification,
   V1_ValueSpecificationVisitor,
@@ -80,13 +80,18 @@ class V1_ValueSpecificationPathResolver
   implements V1_ValueSpecificationVisitor<V1_ValueSpecification>
 {
   context: V1_GraphBuilderContext;
-  hasModifiedLambda = false;
+  /**
+   * This flag is an optimization we do so the consumer can tell if any modification to the protocol
+   * models happened as part of path resolution.
+   */
+  hasModified = false;
+
   constructor(context: V1_GraphBuilderContext) {
     this.context = context;
   }
 
   visit_INTERNAL__UnknownValueSpecfication(
-    spec: V1_INTERNAL__UnknownValueSpecfication,
+    spec: V1_INTERNAL__UnknownValueSpecification,
   ): V1_ValueSpecification {
     return spec;
   }
@@ -323,47 +328,50 @@ function V1_resolveElementPath(
   resolver: V1_ValueSpecificationPathResolver,
 ): string {
   const resolvedPath = resolverFunc(path).value.path;
-  // Note: this handles any system elements + primitive types already resolved. i.e String, ModelStore
   if (resolvedPath !== path) {
-    resolver.hasModifiedLambda = true;
+    resolver.hasModified = true;
   }
   return resolvedPath;
 }
 
 /**
- * Method resolves element paths inside RawLambda
+ * Method resolves element paths inside raw lambda.
+ *
  * To do this we take RawLamba (body: object, parameters: obect) convert it to Lambda and
- * resolve where possible (where an element path is defined as part of the value specification flow.
- * When completed we convert it back to RawLambda.
- * This method ignores any function matching therefore if any time we encounter an error resolving an element path
- * inside the value specification, we continue on the graph unchanging the value spec.
- * We use this new resolved lamba if we have changed any element path (noted by the hasModifiedLambda flag)
- * The whole flow is wrapper around a try/catch and we use the orginal lambda if any errors arise from this flow.
+ * resolve paths using section index where possible (wherever an element path is defined as
+ * part of the value specification flow. When completed we convert it back to raw lambda.
+ *
+ * This method ignores any function matching therefore if any time we encounter an error resolving an
+ * element path inside the value specification, we continue on the graph unchanging the value spec.
+ * We use this new resolved lambda if we have changed any element path.
+ *
+ * NOTE: Here we fail silently, and we would use the orginal lambda if any errors arise from this procedure.
  */
 const V1_resolveLambdaElementPaths = (
-  _context: V1_GraphBuilderContext,
   rawLambdaProtocol: V1_RawLambda,
+  context: V1_GraphBuilderContext,
 ): V1_RawLambda => {
   try {
-    // Convert raw lambda to lambda
+    // Convert raw lambda to V1 lambda
     const lambdaProtocol = V1_deserializeValueSpecification(
       V1_serializeRawValueSpecification(rawLambdaProtocol),
     );
-    // Resolve paths in lambda
-    const resolver = new V1_ValueSpecificationPathResolver(_context);
+    // Resolve paths in V1 lambda
+    const resolver = new V1_ValueSpecificationPathResolver(context);
     lambdaProtocol.accept_ValueSpecificationVisitor(resolver);
-    // if the resolver has modified lambda then convert lambda back to raw lambda and return
-    // else return orginal lambda
-    return resolver.hasModifiedLambda
+    // if the resolver has modified the lambda then convert lambda back to raw lambda and return
+    // else return orginal lambda (this check saves us the work to convert between
+    // raw protocol and protocol forms)
+    return resolver.hasModified
       ? (V1_deserializeRawValueSpecification(
           V1_serializeValueSpecification(lambdaProtocol),
         ) as V1_RawLambda)
       : rawLambdaProtocol;
   } catch (error) {
     assertErrorThrown(error);
-    // return orginal lambda if anything goes wrong
+    // silently return orginal lambda if anything goes wrong
     error.message = `Can't resolve element paths for lambda:\n${error.message}`;
-    _context.log.warn(
+    context.log.warn(
       LogEvent.create(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_FAILURE),
       error,
     );
@@ -371,20 +379,27 @@ const V1_resolveLambdaElementPaths = (
   }
 };
 
-export const V1_resolvePathsInRawLambda = (
-  _context: V1_GraphBuilderContext,
-  parameters?: object,
-  body?: object,
+/**
+ * This method will traverse through the lambda protocol model tree
+ * and **with best effort** try to rewrite the lambda so all shortened
+ * paths inside the lambda are fully resolved.
+ *
+ * This is needed since apps like `Studio` leave value specifications raw/unprocessed
+ * when building the graph, hence any modification to section index or imports
+ * will not apply to the raw value specification (for the contrast, see the
+ * behavior of references)
+ */
+export const V1_buildRawLambdaWithResolvedPaths = (
+  parameters: object | undefined,
+  body: object | undefined,
+  context: V1_GraphBuilderContext,
 ): RawLambda => {
   const rawLambda = new V1_RawLambda();
   rawLambda.parameters = parameters ?? [];
   rawLambda.body = body ?? [];
-  const resolverEnabled =
-    !_context.options?.TEMPORARY__disableRawLambdaResolver &&
-    !_context.options?.TEMPORARY__keepSectionIndex;
   let resolved = rawLambda;
-  if (resolverEnabled) {
-    resolved = V1_resolveLambdaElementPaths(_context, rawLambda);
+  if (context.enableRawLambdaAutoPathResolution) {
+    resolved = V1_resolveLambdaElementPaths(rawLambda, context);
   }
   return new RawLambda(resolved.parameters, resolved.body);
 };

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

@@ -18,6 +18,8 @@ import { serialize, deserialize } from 'serializr';
 import {
   type PlainObject,
   UnsupportedOperationError,
+  assertErrorThrown,
+  guaranteeIsString,
 } from '@finos/legend-shared';
 import type { V1_PackageableConnection } from '../../model/packageableElements/connection/V1_PackageableConnection';
 import type { V1_Association } from '../../model/packageableElements/domain/V1_Association';
@@ -47,7 +49,7 @@ import {
   V1_MAPPING_ELEMENT_PROTOCOL_TYPE,
 } from './serializationHelpers/V1_MappingSerializationHelper';
 import {
-  V1_servicedModelSchema,
+  V1_serviceModelSchema,
   V1_SERVICE_ELEMENT_PROTOCOL_TYPE,
 } from './serializationHelpers/V1_ServiceSerializationHelper';
 import {
@@ -92,8 +94,14 @@ import type {
   PureProtocolProcessorPlugin,
   V1_ElementProtocolSerializer,
 } from '../../../PureProtocolProcessorPlugin';
+import { createPath } from '../../../../../../MetaModelUtils';
+import type { V1_DataElement } from '../../model/packageableElements/data/V1_DataElement';
+import {
+  V1_dataElementModelSchema,
+  V1_DATA_ELEMENT_PROTOCOL_TYPE,
+} from './serializationHelpers/V1_DataElementSerializationHelper';
 
-export class V1_PackageableElementSerializer
+class V1_PackageableElementSerializer
   implements V1_PackageableElementVisitor<PlainObject<V1_PackageableElement>>
 {
   extraElementProtocolSerializers: V1_ElementProtocolSerializer[] = [];
@@ -163,7 +171,7 @@ export class V1_PackageableElementSerializer
   }
 
   visit_Service(element: V1_Service): PlainObject<V1_PackageableElement> {
-    return serialize(V1_servicedModelSchema, element);
+    return serialize(V1_serviceModelSchema(this.plugins), element);
   }
 
   visit_PackageableRuntime(
@@ -198,56 +206,95 @@ export class V1_PackageableElementSerializer
   ): PlainObject<V1_PackageableElement> {
     return serialize(V1_sectionIndexModelSchema, element);
   }
+
+  visit_DataElement(
+    element: V1_DataElement,
+  ): PlainObject<V1_PackageableElement> {
+    return serialize(V1_dataElementModelSchema(this.plugins), element);
+  }
 }
 
+export const V1_serializePackageableElement = (
+  element: V1_PackageableElement,
+  plugins: PureProtocolProcessorPlugin[],
+): PlainObject<V1_PackageableElement> => {
+  try {
+    return element.accept_PackageableElementVisitor(
+      new V1_PackageableElementSerializer(plugins),
+    );
+  } catch (error) {
+    assertErrorThrown(error);
+    error.message = `Can't serialize element '${element.path}': ${error.message}`;
+    throw error;
+  }
+};
+
 export const V1_deserializePackageableElement = (
   json: PlainObject<V1_PackageableElement>,
   plugins: PureProtocolProcessorPlugin[],
 ): V1_PackageableElement => {
-  const extraElementProtocolDeserializers = plugins.flatMap(
-    (plugin) => plugin.V1_getExtraElementProtocolDeserializers?.() ?? [],
+  const packagePath = guaranteeIsString(
+    json.package,
+    `Can't deserialize element: element package is not a string`,
   );
-  switch (json._type) {
-    case V1_PROFILE_ELEMENT_PROTOCOL_TYPE:
-      return deserialize(V1_profileSchema, json);
-    case V1_ENUMERATION_ELEMENT_PROTOCOL_TYPE:
-      return deserialize(V1_enumerationSchema, json);
-    case V1_MEASURE_ELEMENT_PROTOCOL_TYPE:
-      return deserialize(V1_measureSchema, json);
-    case V1_CLASS_ELEMENT_PROTOCOL_TYPE:
-      return deserialize(V1_classSchema, json);
-    case V1_ASSOCIATION_ELEMENT_PROTOCOL_TYPE:
-      return deserialize(V1_associationSchema, json);
-    case V1_FUNCTION_ELEMENT_PROTOCOL_TYPE:
-      return deserialize(V1_functionSchema, json);
-    case V1_FLAT_DATA_ELEMENT_PROTOCOL_TYPE:
-      return deserialize(V1_flatDataModelSchema, json);
-    case V1_DATABASE_ELEMENT_PROTOCOL_TYPE:
-      return deserialize(V1_databaseModelSchema, json);
-    case V1_MAPPING_ELEMENT_PROTOCOL_TYPE:
-      return deserialize(V1_mappingModelSchema(plugins), json);
-    case V1_SERVICE_ELEMENT_PROTOCOL_TYPE:
-      return deserialize(V1_servicedModelSchema, json);
-    case V1_PACKAGEABLE_CONNECTION_ELEMENT_PROTOCOL_TYPE:
-      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:
-      return deserialize(V1_fileGenerationModelSchema, json);
-    case V1_GENERATION_SPECIFICATION_ELEMENT_PROTOCOL_TYPE:
-      return deserialize(V1_generationSpecificationsModelSchema, json);
-    case V1_SECTION_INDEX_ELEMENT_PROTOCOL_TYPE:
-      return deserialize(V1_sectionIndexModelSchema, json);
-    default: {
-      for (const deserializer of extraElementProtocolDeserializers) {
-        const elementProtocol = deserializer(json, plugins);
-        if (elementProtocol) {
-          return elementProtocol;
+  const name = guaranteeIsString(
+    json.name,
+    `Can't deserialize element: element name is not a string`,
+  );
+  const elementPath = createPath(packagePath, name);
+
+  try {
+    const extraElementProtocolDeserializers = plugins.flatMap(
+      (plugin) => plugin.V1_getExtraElementProtocolDeserializers?.() ?? [],
+    );
+    switch (json._type) {
+      case V1_PROFILE_ELEMENT_PROTOCOL_TYPE:
+        return deserialize(V1_profileSchema, json);
+      case V1_ENUMERATION_ELEMENT_PROTOCOL_TYPE:
+        return deserialize(V1_enumerationSchema, json);
+      case V1_MEASURE_ELEMENT_PROTOCOL_TYPE:
+        return deserialize(V1_measureSchema, json);
+      case V1_CLASS_ELEMENT_PROTOCOL_TYPE:
+        return deserialize(V1_classSchema, json);
+      case V1_ASSOCIATION_ELEMENT_PROTOCOL_TYPE:
+        return deserialize(V1_associationSchema, json);
+      case V1_FUNCTION_ELEMENT_PROTOCOL_TYPE:
+        return deserialize(V1_functionSchema, json);
+      case V1_FLAT_DATA_ELEMENT_PROTOCOL_TYPE:
+        return deserialize(V1_flatDataModelSchema, json);
+      case V1_DATABASE_ELEMENT_PROTOCOL_TYPE:
+        return deserialize(V1_databaseModelSchema, json);
+      case V1_MAPPING_ELEMENT_PROTOCOL_TYPE:
+        return deserialize(V1_mappingModelSchema(plugins), json);
+      case V1_SERVICE_ELEMENT_PROTOCOL_TYPE:
+        return deserialize(V1_serviceModelSchema(plugins), json);
+      case V1_PACKAGEABLE_CONNECTION_ELEMENT_PROTOCOL_TYPE:
+        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:
+        return deserialize(V1_fileGenerationModelSchema, json);
+      case V1_GENERATION_SPECIFICATION_ELEMENT_PROTOCOL_TYPE:
+        return deserialize(V1_generationSpecificationsModelSchema, json);
+      case V1_SECTION_INDEX_ELEMENT_PROTOCOL_TYPE:
+        return deserialize(V1_sectionIndexModelSchema, json);
+      case V1_DATA_ELEMENT_PROTOCOL_TYPE:
+        return deserialize(V1_dataElementModelSchema(plugins), json);
+      default: {
+        for (const deserializer of extraElementProtocolDeserializers) {
+          const elementProtocol = deserializer(json, plugins);
+          if (elementProtocol) {
+            return elementProtocol;
+          }
         }
+        throw new UnsupportedOperationError(
+          `Can't deserialize element of type '${json._type}': no compatible deserializer available from plugins`,
+        );
       }
-      throw new UnsupportedOperationError(
-        `Can't deserialize element of type '${json._type}': no compatible deserializer available from plugins`,
-      );
     }
+  } catch (error) {
+    assertErrorThrown(error);
+    error.message = `Can't deserialize element '${elementPath}': ${error.message}`;
+    throw error;
   }
 };

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

@@ -36,8 +36,8 @@ import { V1_PureModelContextData } from '../../model/context/V1_PureModelContext
 import { V1_PureModelContextPointer } from '../../model/context/V1_PureModelContextPointer';
 import type { V1_PackageableElement } from '../../model/packageableElements/V1_PackageableElement';
 import {
+  V1_serializePackageableElement,
   V1_deserializePackageableElement,
-  V1_PackageableElementSerializer,
 } from '../../transformation/pureProtocol/V1_PackageableElementSerialization';
 import { V1_PureModelContextComposite } from '../../model/context/V1_PureModelContextComposite';
 import { V1_Protocol } from '../../model/V1_Protocol';
@@ -149,9 +149,7 @@ export const V1_setupPureModelContextDataSerialization = (
     elements: list(
       custom(
         (element: V1_PackageableElement) =>
-          element.accept_PackageableElementVisitor(
-            new V1_PackageableElementSerializer(plugins),
-          ),
+          V1_serializePackageableElement(element, plugins),
         (element: PlainObject<V1_PackageableElement>) =>
           V1_deserializePackageableElement(element, plugins),
       ),

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

@@ -30,6 +30,8 @@ import {
   usingConstantValueSchema,
   IllegalStateError,
   UnsupportedOperationError,
+  serializeArray,
+  deserializeArray,
 } from '@finos/legend-shared';
 import { V1_ModelChainConnection } from '../../../model/packageableElements/store/modelToModel/connection/V1_ModelChainConnection';
 import { V1_PackageableConnection } from '../../../model/packageableElements/connection/V1_PackageableConnection';
@@ -90,7 +92,15 @@ export const V1_modelChainConnectionModelSchema = createModelSchema(
   V1_ModelChainConnection,
   {
     _type: usingConstantValueSchema(V1_ConnectionType.MODEL_CHAIN_CONNECTION),
-    store: alias('element', 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
+     */
+    store: alias('element', optional(primitive())),
     mappings: list(primitive()),
   },
 );
@@ -100,7 +110,15 @@ export const V1_jsonModelConnectionModelSchema = createModelSchema(
   {
     _type: usingConstantValueSchema(V1_ConnectionType.JSON_MODEL_CONNECTION),
     class: primitive(),
-    store: alias('element', 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
+     */
+    store: alias('element', optional(primitive())),
     url: primitive(),
   },
 );
@@ -110,7 +128,15 @@ export const V1_xmlModelConnectionModelSchema = createModelSchema(
   {
     _type: usingConstantValueSchema(V1_ConnectionType.XML_MODEL_CONNECTION),
     class: primitive(),
-    store: alias('element', 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
+     */
+    store: alias('element', optional(primitive())),
     url: primitive(),
   },
 );
@@ -161,7 +187,16 @@ const localH2DatasourceSpecificationModelSchema = createModelSchema(
   {
     _type: usingConstantValueSchema(V1_DatasourceSpecificationType.H2_LOCAL),
     testDataSetupCsv: optional(primitive()),
-    testDataSetupSqls: list(primitive()),
+    testDataSetupSqls: custom(
+      (values) =>
+        serializeArray(values, (value) => value, {
+          skipIfEmpty: true,
+        }),
+      (values) =>
+        deserializeArray(values, (v) => v, {
+          skipIfEmpty: false,
+        }),
+    ),
   },
 );