@finos/legend-graph 5.0.0 → 6.0.0

package/src/models/protocols/pure/v1/transformation/pureGraph/from/V1_PackageableElementTransformer.ts

@@ -64,6 +64,8 @@ import type {
   PureProtocolProcessorPlugin,
 } from '../../../../PureProtocolProcessorPlugin';
 import type { V1_GraphTransformerContext } from './V1_GraphTransformerContext';
+import type { DataElement } from '../../../../../../metamodels/pure/packageableElements/data/DataElement';
+import { V1_transformDataElement } from './V1_DataElementTransformer';
 
 class V1_PackageableElementTransformer
   implements PackageableElementVisitor<V1_PackageableElement>
@@ -169,6 +171,10 @@ class V1_PackageableElementTransformer
   ): V1_PackageableElement {
     return V1_transformGenerationSpecification(element);
   }
+
+  visit_DataElement(element: DataElement): V1_PackageableElement {
+    return V1_transformDataElement(element, this.context);
+  }
 }
 
 export const V1_transformPackageableElement = (

package/src/models/protocols/pure/v1/transformation/pureGraph/from/V1_ServiceTransformer.ts

@@ -16,13 +16,7 @@
 
 import { UnsupportedOperationError } from '@finos/legend-shared';
 import type { Service } from '../../../../../../metamodels/pure/packageableElements/service/Service';
-import {
-  type KeyedSingleExecutionTest,
-  type ServiceTest,
-  type TestContainer,
-  MultiExecutionTest,
-  SingleExecutionTest,
-} from '../../../../../../metamodels/pure/packageableElements/service/ServiceTest';
+import type { ServiceTest } from '../../../../../../metamodels/pure/packageableElements/service/ServiceTest';
 import {
   type KeyedExecutionParameter,
   type ServiceExecution,
@@ -40,13 +34,7 @@ import {
   V1_PureMultiExecution,
   V1_KeyedExecutionParameter,
 } from '../../../model/packageableElements/service/V1_ServiceExecution';
-import {
-  type V1_ServiceTest,
-  V1_MultiExecutionTest,
-  V1_TestContainer,
-  V1_SingleExecutionTest,
-  V1_KeyedSingleExecutionTest,
-} from '../../../model/packageableElements/service/V1_ServiceTest';
+import { V1_ServiceTest } from '../../../model/packageableElements/service/V1_ServiceTest';
 import { V1_RawValueSpecificationTransformer } from './V1_RawValueSpecificationTransformer';
 import type { V1_RawLambda } from '../../../model/rawValueSpecification/V1_RawLambda';
 import { V1_transformRuntime } from './V1_RuntimeTransformer';
@@ -55,6 +43,92 @@ import {
   V1_transformStereotype,
   V1_transformTaggedValue,
 } from './V1_DomainTransformer';
+import {
+  type DEPRECATED__ServiceTest,
+  type DEPRECATED__KeyedSingleExecutionTest,
+  type DEPRECATED__TestContainer,
+  DEPRECATED__MultiExecutionTest,
+  DEPRECATED__SingleExecutionTest,
+} from '../../../../../../metamodels/pure/packageableElements/service/DEPRECATED__ServiceTest';
+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 { ConnectionTestData } from '../../../../../../metamodels/pure/packageableElements/service/ConnectionTestData';
+import { V1_ConnectionTestData } from '../../../model/packageableElements/service/V1_ConnectionTestData';
+import { V1_transformEmbeddedData } from './V1_DataElementTransformer';
+import { V1_ParameterValue } from '../../../model/packageableElements/service/V1_ParameterValue';
+import type { ParameterValue } from '../../../../../../metamodels/pure/packageableElements/service/ParameterValue';
+import type { TestData } from '../../../../../../metamodels/pure/packageableElements/service/ServiceTestData';
+import { V1_TestData } from '../../../model/packageableElements/service/V1_TestData';
+import { V1_ServiceTestSuite } from '../../../model/packageableElements/service/V1_ServiceTestSuite';
+import type { ServiceTestSuite } from '../../../../../../metamodels/pure/packageableElements/service/ServiceTestSuite';
+import {
+  V1_transformAtomicTest,
+  V1_transformTestAssertion,
+  V1_transformTestSuite,
+} from './V1_TestTransformer';
+
+const transformConnectionTestData = (
+  element: ConnectionTestData,
+  context: V1_GraphTransformerContext,
+): V1_ConnectionTestData => {
+  const connectionTestData = new V1_ConnectionTestData();
+  connectionTestData.id = element.connectionId;
+  connectionTestData.data = V1_transformEmbeddedData(element.testData, context);
+  return connectionTestData;
+};
+
+const transformParameterValue = (
+  element: ParameterValue,
+): V1_ParameterValue => {
+  const parameterValue = new V1_ParameterValue();
+  parameterValue.name = element.name;
+  parameterValue.value = element.value;
+  return parameterValue;
+};
+
+const transformTestData = (
+  element: TestData,
+  context: V1_GraphTransformerContext,
+): V1_TestData => {
+  const testData = new V1_TestData();
+  testData.connectionsTestData = element.connectionsTestData.map(
+    (connectionTestData) =>
+      transformConnectionTestData(connectionTestData, context),
+  );
+  return testData;
+};
+
+export const V1_transformServiceTest = (
+  element: ServiceTest,
+): V1_ServiceTest => {
+  const serviceTest = new V1_ServiceTest();
+  serviceTest.id = element.id;
+  serviceTest.parameters = element.parameters.map((parameter) =>
+    transformParameterValue(parameter),
+  );
+  serviceTest.assertions = element.assertions.map((assertion) =>
+    V1_transformTestAssertion(assertion),
+  );
+  return serviceTest;
+};
+
+export const V1_transformServiceTestSuite = (
+  element: ServiceTestSuite,
+  context: V1_GraphTransformerContext,
+): V1_ServiceTestSuite => {
+  const serviceTestSuite = new V1_ServiceTestSuite();
+  serviceTestSuite.id = element.id;
+  serviceTestSuite.testData = transformTestData(element.testData, context);
+  serviceTestSuite.tests = element.tests.map((test) =>
+    V1_transformAtomicTest(test),
+  );
+  return serviceTestSuite;
+};
 
 const transformSingleExecution = (
   element: PureSingleExecution,
@@ -111,10 +185,10 @@ const transformServiceExecution = (
 };
 
 const transformTestContainer = (
-  element: TestContainer,
+  element: DEPRECATED__TestContainer,
   context: V1_GraphTransformerContext,
-): V1_TestContainer => {
-  const container = new V1_TestContainer();
+): V1_DEPRECATED__TestContainer => {
+  const container = new V1_DEPRECATED__TestContainer();
   container.assert = element.assert.accept_RawValueSpecificationVisitor(
     new V1_RawValueSpecificationTransformer(context),
   ) as V1_RawLambda;
@@ -123,10 +197,10 @@ const transformTestContainer = (
 };
 
 const transformSingleExecutionTest = (
-  element: SingleExecutionTest,
+  element: DEPRECATED__SingleExecutionTest,
   context: V1_GraphTransformerContext,
-): V1_SingleExecutionTest => {
-  const single = new V1_SingleExecutionTest();
+): V1_DEPRECATED__SingleExecutionTest => {
+  const single = new V1_DEPRECATED__SingleExecutionTest();
   single.asserts = element.asserts
     .filter((testContainer) => testContainer.assert.body !== undefined)
     .map((testContainer) => transformTestContainer(testContainer, context));
@@ -135,10 +209,10 @@ const transformSingleExecutionTest = (
 };
 
 const transformKeyedSingleExecutionTest = (
-  element: KeyedSingleExecutionTest,
+  element: DEPRECATED__KeyedSingleExecutionTest,
   context: V1_GraphTransformerContext,
-): V1_KeyedSingleExecutionTest => {
-  const keyedTest = new V1_KeyedSingleExecutionTest();
+): V1_DEPRECATED__KeyedSingleExecutionTest => {
+  const keyedTest = new V1_DEPRECATED__KeyedSingleExecutionTest();
   keyedTest.asserts = element.asserts
     .filter((testContainer) => testContainer.assert.body !== undefined)
     .map((testContainer) => transformTestContainer(testContainer, context));
@@ -148,23 +222,23 @@ const transformKeyedSingleExecutionTest = (
 };
 
 const transformMultiExecutiontest = (
-  element: MultiExecutionTest,
+  element: DEPRECATED__MultiExecutionTest,
   context: V1_GraphTransformerContext,
-): V1_MultiExecutionTest => {
-  const multi = new V1_MultiExecutionTest();
+): V1_DEPRECATED__MultiExecutionTest => {
+  const multi = new V1_DEPRECATED__MultiExecutionTest();
   multi.tests = element.tests.map((test) =>
     transformKeyedSingleExecutionTest(test, context),
   );
   return multi;
 };
 
-const transformServiceTest = (
-  value: ServiceTest,
+const transformLegacyServiceTest = (
+  value: DEPRECATED__ServiceTest,
   context: V1_GraphTransformerContext,
-): V1_ServiceTest => {
-  if (value instanceof SingleExecutionTest) {
+): V1_DEPRECATED__ServiceTest => {
+  if (value instanceof DEPRECATED__SingleExecutionTest) {
     return transformSingleExecutionTest(value, context);
-  } else if (value instanceof MultiExecutionTest) {
+  } else if (value instanceof DEPRECATED__MultiExecutionTest) {
     return transformMultiExecutiontest(value, context);
   }
   throw new UnsupportedOperationError(`Can't transform service test`, value);
@@ -183,6 +257,11 @@ export const V1_transformService = (
   service.execution = transformServiceExecution(element.execution, context);
   service.owners = element.owners;
   service.pattern = element.pattern;
-  service.test = transformServiceTest(element.test, context);
+  if (element.test) {
+    service.test = transformLegacyServiceTest(element.test, context);
+  }
+  service.testSuites = element.tests.map((testSuite) =>
+    V1_transformTestSuite(testSuite, context),
+  );
   return service;
 };

package/src/models/protocols/pure/v1/transformation/pureGraph/from/V1_TestTransformer.ts

@@ -0,0 +1,176 @@
+/**
+ * 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 { UnsupportedOperationError } from '@finos/legend-shared';
+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 { 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_AtomicTestId } from '../../../model/test/V1_AtomicTestId';
+import { V1_EqualTo } from '../../../model/test/assertion/V1_EqualTo';
+import { V1_EqualToJson } from '../../../model/test/assertion/V1_EqualToJson';
+import { EqualTo } from '../../../../../../metamodels/pure/test/assertion/EqualTo';
+import { EqualToJson } from '../../../../../../metamodels/pure/test/assertion/EqualToJson';
+import { V1_transformExternalFormatData } from './V1_DataElementTransformer';
+import type { V1_AtomicTest } from '../../../model/test/V1_AtomicTest';
+import { ServiceTest } from '../../../../../../metamodels/pure/packageableElements/service/ServiceTest';
+import type { V1_TestAssertion } from '../../../model/test/assertion/V1_TestAssertion';
+import type { TestAssertion } from '../../../../../../metamodels/pure/test/assertion/TestAssertion';
+import type { V1_TestSuite } from '../../../model/test/V1_TestSuite';
+import { V1_TestResult } from '../../../model/test/result/V1_TestResult';
+import { V1_TestPassed } from '../../../model/test/result/V1_TestPassed';
+import { V1_TestFailed } from '../../../model/test/result/V1_TestFailed';
+import { V1_TestError } from '../../../model/test/result/V1_TestError';
+import type { TestResult } from '../../../../../../metamodels/pure/test/result/TestResult';
+import type { TestPassed } from '../../../../../../metamodels/pure/test/result/TestPassed';
+import type { TestFailed } from '../../../../../../metamodels/pure/test/result/TestFailed';
+import type { TestError } from '../../../../../../metamodels/pure/test/result/TestError';
+import {
+  V1_transformServiceTest,
+  V1_transformServiceTestSuite,
+} from './V1_ServiceTransformer';
+import { ServiceTestSuite } from '../../../../../../metamodels/pure/packageableElements/service/ServiceTestSuite';
+import type { V1_GraphTransformerContext } from './V1_GraphTransformerContext';
+import type { AtomicTestId } from '../../../../../../metamodels/pure/test/result/AtomicTestId';
+import type {
+  AtomicTest,
+  TestSuite,
+} from '../../../../../../metamodels/pure/test/Test';
+
+const transformAtomicTestId = (element: AtomicTestId): V1_AtomicTestId => {
+  const atomicTestId = new V1_AtomicTestId();
+  atomicTestId.atomicTestId = element.atomicTestId;
+  atomicTestId.testSuiteId = element.testSuiteId;
+  return atomicTestId;
+};
+
+const transformAssertFail = (element: AssertFail): V1_AssertFail => {
+  const assertFail = new V1_AssertFail();
+  assertFail.id = element.id;
+  assertFail.message = element.message;
+  return assertFail;
+};
+
+const transformAssertPass = (element: AssertPass): V1_AssertPass => {
+  const assertPass = new V1_AssertPass();
+  assertPass.id = element.id;
+  return assertPass;
+};
+
+const transformEqualToJsonAssertFail = (
+  element: EqualToJsonAssertFail,
+): V1_EqualToJsonAssertFail => {
+  const equalToJsonAssertFail = new V1_EqualToJsonAssertFail();
+  equalToJsonAssertFail.id = element.id;
+  equalToJsonAssertFail.message = element.message;
+  equalToJsonAssertFail.actual = element.actual;
+  equalToJsonAssertFail.expected = element.expected;
+  return equalToJsonAssertFail;
+};
+
+const transformAssertionStatus = (
+  value: AssertionStatus,
+): V1_AssertionStatus => {
+  if (value instanceof EqualToJsonAssertFail) {
+    return transformEqualToJsonAssertFail(value);
+  } else if (value instanceof AssertFail) {
+    return transformAssertFail(value);
+  } else if (value instanceof AssertPass) {
+    return transformAssertPass(value);
+  }
+  throw new UnsupportedOperationError(
+    `Can't transform assertion status`,
+    value,
+  );
+};
+
+const transformEqualTo = (element: EqualTo): V1_EqualTo => {
+  const equalTo = new V1_EqualTo();
+  equalTo.id = element.id;
+  equalTo.expected = element.expected;
+  return equalTo;
+};
+
+const transformEqualToJson = (element: EqualToJson): V1_EqualToJson => {
+  const equalToJson = new V1_EqualToJson();
+  equalToJson.id = element.id;
+  equalToJson.expected = V1_transformExternalFormatData(element.expected);
+  return equalToJson;
+};
+
+export const V1_transformTestError = (element: TestError): V1_TestError => {
+  const testError = new V1_TestError();
+  testError.testable = element.testable;
+  testError.error = element.error;
+  testError.atomicTestId = transformAtomicTestId(element.atomicTestId);
+  return testError;
+};
+
+export const V1_transformTestFailed = (element: TestFailed): V1_TestFailed => {
+  const testFailed = new V1_TestFailed();
+  testFailed.testable = element.testable;
+  testFailed.atomicTestId = transformAtomicTestId(element.atomicTestId);
+  testFailed.assertStatuses = element.assertStatuses.map((assertStatus) =>
+    transformAssertionStatus(assertStatus),
+  );
+  return testFailed;
+};
+
+export const V1_transformTestPassed = (element: TestPassed): V1_TestPassed => {
+  const testPassed = new V1_TestPassed();
+  testPassed.testable = element.testable;
+  testPassed.atomicTestId = transformAtomicTestId(element.atomicTestId);
+  return testPassed;
+};
+
+export const V1_transformTestResult = (element: TestResult): V1_TestResult => {
+  const testResult = new V1_TestResult();
+  testResult.testable = element.testable;
+  testResult.atomicTestId = transformAtomicTestId(element.atomicTestId);
+  return testResult;
+};
+
+export const V1_transformAtomicTest = (value: AtomicTest): V1_AtomicTest => {
+  if (value instanceof ServiceTest) {
+    return V1_transformServiceTest(value);
+  }
+  throw new UnsupportedOperationError(`Can't transform atomic test`, value);
+};
+
+export const V1_transformTestAssertion = (
+  value: TestAssertion,
+): V1_TestAssertion => {
+  if (value instanceof EqualTo) {
+    return transformEqualTo(value);
+  } else if (value instanceof EqualToJson) {
+    return transformEqualToJson(value);
+  }
+  throw new UnsupportedOperationError(`Can't transform test assertion`, value);
+};
+
+export const V1_transformTestSuite = (
+  value: TestSuite,
+  context: V1_GraphTransformerContext,
+): V1_TestSuite => {
+  if (value instanceof ServiceTestSuite) {
+    return V1_transformServiceTestSuite(value, context);
+  }
+  throw new UnsupportedOperationError(`Can't transform test suite`, value);
+};

package/src/models/protocols/pure/v1/transformation/pureGraph/from/V1_ValueSpecificationTransformer.ts

@@ -81,7 +81,8 @@ import { V1_HackedUnit } from '../../../model/valueSpecification/raw/V1_HackedUn
 import { V1_HackedClass } from '../../../model/valueSpecification/raw/V1_HackedClass';
 import type { PackageableElement } from '../../../../../../metamodels/pure/packageableElements/PackageableElement';
 import type { INTERNAL__UnknownValueSpecification } from '../../../../../../metamodels/pure/valueSpecification/INTERNAL__UnknownValueSpecification';
-import { V1_INTERNAL__UnknownValueSpecfication } from '../../../model/valueSpecification/V1_INTERNAL__UnknownValueSpecfication';
+import { V1_INTERNAL__UnknownValueSpecification } from '../../../model/valueSpecification/V1_INTERNAL__UnknownValueSpecfication';
+import type { INTERNAL__PropagatedValue } from '../../../../../../metamodels/pure/valueSpecification/INTERNAL__PropagatedValue';
 
 class V1_ValueSpecificationTransformer
   implements ValueSpecificationVisitor<V1_ValueSpecification>
@@ -106,7 +107,7 @@ class V1_ValueSpecificationTransformer
   visit_INTERNAL__UnknownValueSpecification(
     valueSpecification: INTERNAL__UnknownValueSpecification,
   ): V1_ValueSpecification {
-    const protocol = new V1_INTERNAL__UnknownValueSpecfication();
+    const protocol = new V1_INTERNAL__UnknownValueSpecification();
     protocol.content = valueSpecification.content;
     return protocol;
   }
@@ -385,6 +386,12 @@ class V1_ValueSpecificationTransformer
     );
     return _property;
   }
+
+  visit_INTERNAL__PropagatedValue(
+    valueSpecification: INTERNAL__PropagatedValue,
+  ): V1_ValueSpecification {
+    throw new UnsupportedOperationError();
+  }
 }
 
 export function V1_transformGraphFetchTree(

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

@@ -79,6 +79,7 @@ import type { V1_GraphBuilderExtensions } from './V1_GraphBuilderExtensions';
 import type { GraphBuilderOptions } from '../../../../../../../graphManager/AbstractPureGraphManager';
 import { DataType } from '../../../../../../metamodels/pure/packageableElements/domain/DataType';
 import { GraphBuilderError } from '../../../../../../../graphManager/GraphManagerUtils';
+import type { DataElement } from '../../../../../../../DSLData_Exports';
 
 export const V1_buildFullPath = (
   packagePath: string | undefined,
@@ -513,6 +514,13 @@ export class V1_GraphBuilderContext {
       path,
       this.graph.getFileGeneration,
     );
+  resolveDataElement = (
+    path: string,
+  ): PackageableElementImplicitReference<DataElement> =>
+    this.createImplicitPackageableElementReference(
+      path,
+      this.graph.getDataElement,
+    );
 }
 
 export class V1_GraphBuilderContextBuilder {

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

@@ -43,6 +43,7 @@ import type { V1_GenerationSpecification } from '../../../model/packageableEleme
 import type { V1_Measure } from '../../../model/packageableElements/domain/V1_Measure';
 import { V1_buildDatabaseSchemaViewsSecondPass } from './helpers/V1_DatabaseBuilderHelper';
 import type { V1_SectionIndex } from '../../../model/packageableElements/section/V1_SectionIndex';
+import type { V1_DataElement } from '../../../model/packageableElements/data/V1_DataElement';
 
 export class V1_ProtocolToMetaModelGraphFifthPassBuilder
   implements V1_PackageableElementVisitor<void>
@@ -134,4 +135,8 @@ export class V1_ProtocolToMetaModelGraphFifthPassBuilder
   visit_PackageableConnection(element: V1_PackageableConnection): void {
     throw new UnsupportedOperationError();
   }
+
+  visit_DataElement(element: V1_DataElement): void {
+    throw new UnsupportedOperationError();
+  }
 }

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

@@ -65,6 +65,8 @@ import {
 } from '../../../../../../../helpers/DomainHelper';
 import { V1_checkDuplicatedElement } from './V1_ElementBuilder';
 import type { Package } from '../../../../../../metamodels/pure/packageableElements/domain/Package';
+import type { V1_DataElement } from '../../../model/packageableElements/data/V1_DataElement';
+import { DataElement } from '../../../../../../metamodels/pure/packageableElements/data/DataElement';
 
 export class V1_ProtocolToMetaModelGraphFirstPassBuilder
   implements V1_PackageableElementVisitor<PackageableElement>
@@ -467,4 +469,28 @@ export class V1_ProtocolToMetaModelGraphFirstPassBuilder
     this.context.currentSubGraph.setOwnConnection(path, connection);
     return connection;
   }
+
+  visit_DataElement(element: V1_DataElement): PackageableElement {
+    assertNonEmptyString(
+      element.package,
+      `Data element 'package' field is missing or empty`,
+    );
+    assertNonEmptyString(
+      element.name,
+      `Data element 'name' field is missing or empty`,
+    );
+    const dataElement = new DataElement(element.name);
+    const path = V1_buildFullPath(element.package, element.name);
+    V1_checkDuplicatedElement(path, this.context, this.elementPathCache);
+    addElementToPackage(
+      getOrCreateGraphPackage(
+        this.context.currentSubGraph,
+        element.package,
+        this.packageCache,
+      ),
+      dataElement,
+    );
+    this.context.currentSubGraph.setOwnDataElement(path, dataElement);
+    return dataElement;
+  }
 }

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

@@ -48,6 +48,8 @@ import {
 } from './helpers/V1_DatabaseBuilderHelper';
 import type { V1_SectionIndex } from '../../../model/packageableElements/section/V1_SectionIndex';
 import { V1_buildAssociationMapping } from './helpers/V1_AssociationMappingHelper';
+import { V1_buildMilestoningProperties } from './helpers/V1_MilestoneBuilderHelper';
+import type { V1_DataElement } from '../../../model/packageableElements/data/V1_DataElement';
 
 export class V1_ProtocolToMetaModelGraphFourthPassBuilder
   implements V1_PackageableElementVisitor<void>
@@ -77,13 +79,17 @@ export class V1_ProtocolToMetaModelGraphFourthPassBuilder
   }
 
   visit_Class(element: V1_Class): void {
-    // TODO?: milestoning (process properties and class)
-    throw new UnsupportedOperationError();
+    const _class = this.context.currentSubGraph.getOwnClass(
+      V1_buildFullPath(element.package, element.name),
+    );
+    V1_buildMilestoningProperties(_class, this.context.graph);
   }
 
   visit_Association(element: V1_Association): void {
-    // TODO?: milestoning (process properties)
-    throw new UnsupportedOperationError();
+    const association = this.context.currentSubGraph.getOwnAssociation(
+      V1_buildFullPath(element.package, element.name),
+    );
+    V1_buildMilestoningProperties(association, this.context.graph);
   }
 
   visit_ConcreteFunctionDefinition(
@@ -153,4 +159,8 @@ export class V1_ProtocolToMetaModelGraphFourthPassBuilder
   visit_PackageableConnection(element: V1_PackageableConnection): void {
     throw new UnsupportedOperationError();
   }
+
+  visit_DataElement(element: V1_DataElement): void {
+    throw new UnsupportedOperationError();
+  }
 }

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

@@ -22,6 +22,7 @@ import {
   assertNonNullable,
   assertTrue,
   LogEvent,
+  guaranteeType,
 } from '@finos/legend-shared';
 import { Stereotype } from '../../../../../../metamodels/pure/packageableElements/domain/Stereotype';
 import { Tag } from '../../../../../../metamodels/pure/packageableElements/domain/Tag';
@@ -50,8 +51,8 @@ import {
   V1_buildTaggedValue,
 } from '../../../transformation/pureGraph/to/helpers/V1_DomainBuilderHelper';
 import {
-  V1_buildServiceTest,
   V1_buildServiceExecution,
+  V1_buildLegacyServiceTest,
 } from '../../../transformation/pureGraph/to/helpers/V1_ServiceBuilderHelper';
 import {
   V1_buildEnumerationMapping,
@@ -76,6 +77,10 @@ import {
 import type { V1_Measure } from '../../../model/packageableElements/domain/V1_Measure';
 import type { V1_SectionIndex } from '../../../model/packageableElements/section/V1_SectionIndex';
 import { V1_buildSection } from '../../../transformation/pureGraph/to/helpers/V1_SectionBuilderHelper';
+import type { V1_DataElement } from '../../../model/packageableElements/data/V1_DataElement';
+import { V1_ProtocolToMetaModelEmbeddedDataBuilder } from './helpers/V1_DataElementBuilderHelper';
+import { V1_buildTestSuite } from './helpers/V1_TestBuilderHelper';
+import { ServiceTestSuite } from '../../../../../../metamodels/pure/packageableElements/service/ServiceTestSuite';
 
 export class V1_ProtocolToMetaModelGraphSecondPassBuilder
   implements V1_PackageableElementVisitor<void>
@@ -99,7 +104,13 @@ export class V1_ProtocolToMetaModelGraphSecondPassBuilder
     const uniqueStereotypes = new Set<string>();
     profile.stereotypes = element.stereotypes.map((stereotype) => {
       if (uniqueStereotypes.has(stereotype)) {
-        /* @MARKER: RELAXED GRAPH CHECK - See https://github.com/finos/legend-studio/issues/660 */
+        /**
+         * This test is skipped because we want to temporarily relax graph building algorithm
+         * to ease Pure -> Legend migration push.
+         * See https://github.com/finos/legend-studio/issues/660
+         *
+         * @discrepancy graph-building
+         */
         this.context.log.warn(
           LogEvent.create(
             `Found duplicated stereotype '${stereotype}' in profile '${element.path}'`,
@@ -112,7 +123,13 @@ export class V1_ProtocolToMetaModelGraphSecondPassBuilder
     const uniqueTags = new Set<string>();
     profile.tags = element.tags.map((tag) => {
       if (uniqueTags.has(tag)) {
-        /* @MARKER: RELAXED GRAPH CHECK - See https://github.com/finos/legend-studio/issues/660 */
+        /**
+         * This test is skipped because we want to temporarily relax graph building algorithm
+         * to ease Pure -> Legend migration push.
+         * See https://github.com/finos/legend-studio/issues/660
+         *
+         * @discrepancy graph-building
+         */
         this.context.log.warn(
           LogEvent.create(
             `Found duplicated tag '${tag}' in profile '${element.path}'`,
@@ -141,7 +158,13 @@ export class V1_ProtocolToMetaModelGraphSecondPassBuilder
         `Enum value 'value' field is missing or empty`,
       );
       if (uniqueEnumValues.has(enumValue.value)) {
-        /* @MARKER: RELAXED GRAPH CHECK - See https://github.com/finos/legend-studio/issues/660 */
+        /**
+         * This test is skipped because we want to temporarily relax graph building algorithm
+         * to ease Pure -> Legend migration push.
+         * See https://github.com/finos/legend-studio/issues/660
+         *
+         * @discrepancy graph-building
+         */
         this.context.log.warn(
           LogEvent.create(
             `Found duplicated value '${enumValue.value}' in enumeration '${enumeration.path}'`,
@@ -296,7 +319,16 @@ export class V1_ProtocolToMetaModelGraphSecondPassBuilder
       this.context,
       service,
     );
-    service.test = V1_buildServiceTest(element.test, this.context, service);
+    if (element.test) {
+      service.test = V1_buildLegacyServiceTest(
+        element.test,
+        this.context,
+        service,
+      );
+    }
+    service.tests = element.testSuites
+      .map((testSuite) => V1_buildTestSuite(testSuite, this.context))
+      .map((e) => guaranteeType(e, ServiceTestSuite));
   }
 
   visit_SectionIndex(element: V1_SectionIndex): void {
@@ -362,4 +394,19 @@ export class V1_ProtocolToMetaModelGraphSecondPassBuilder
         new V1_ProtocolToMetaModelConnectionBuilder(this.context),
       );
   }
+
+  visit_DataElement(element: V1_DataElement): void {
+    const dataElement = this.context.currentSubGraph.getOwnDataElement(
+      V1_buildFullPath(element.package, element.name),
+    );
+    dataElement.stereotypes = element.stereotypes
+      .map((stereotype) => this.context.resolveStereotype(stereotype))
+      .filter(isNonNullable);
+    dataElement.taggedValues = element.taggedValues
+      .map((taggedValue) => V1_buildTaggedValue(taggedValue, this.context))
+      .filter(isNonNullable);
+    dataElement.data = element.data.accept_EmbeddedDataVisitor(
+      new V1_ProtocolToMetaModelEmbeddedDataBuilder(this.context),
+    );
+  }
 }