@finos/legend-graph 4.0.2 → 6.0.0

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

@@ -38,15 +38,21 @@ import type {
   PropertyOwner,
 } from '../../../../../../../metamodels/pure/packageableElements/domain/AbstractProperty';
 import type { V1_ValueSpecification } from '../../../../model/valueSpecification/V1_ValueSpecification';
-import type { V1_GraphBuilderContext } from '../../../../transformation/pureGraph/to/V1_GraphBuilderContext';
+import {
+  V1_buildFullPath,
+  type V1_GraphBuilderContext,
+} from '../../../../transformation/pureGraph/to/V1_GraphBuilderContext';
 import type { V1_Constraint } from '../../../../model/packageableElements/domain/V1_Constraint';
 import type { V1_RawVariable } from '../../../../model/rawValueSpecification/V1_RawVariable';
 import type { V1_Property } from '../../../../model/packageableElements/domain/V1_Property';
 import type { V1_DerivedProperty } from '../../../../model/packageableElements/domain/V1_DerivedProperty';
 import type { V1_Unit } from '../../../../model/packageableElements/domain/V1_Measure';
 import type { V1_TaggedValue } from '../../../../model/packageableElements/domain/V1_TaggedValue';
-import { V1_resolvePathsInRawLambda } from './V1_ValueSpecificationPathResolver';
-import { _package_addElement } from '../../../../../../../../helpers/DomainHelper';
+import { V1_buildRawLambdaWithResolvedPaths } from './V1_ValueSpecificationPathResolver';
+import {
+  addElementToPackage,
+  getOrCreateGraphPackage,
+} from '../../../../../../../../helpers/DomainHelper';
 
 export const V1_buildTaggedValue = (
   taggedValue: V1_TaggedValue,
@@ -75,19 +81,19 @@ export const V1_buildConstraint = (
   const pureConstraint = new Constraint(
     constraint.name,
     _class,
-    V1_resolvePathsInRawLambda(
-      context,
+    V1_buildRawLambdaWithResolvedPaths(
       constraint.functionDefinition.parameters,
       constraint.functionDefinition.body,
+      context,
     ),
   );
   pureConstraint.enforcementLevel = constraint.enforcementLevel;
   pureConstraint.externalId = constraint.externalId;
   pureConstraint.messageFunction = constraint.messageFunction
-    ? V1_resolvePathsInRawLambda(
-        context,
+    ? V1_buildRawLambdaWithResolvedPaths(
         constraint.messageFunction.parameters,
         constraint.messageFunction.body,
+        context,
       )
     : constraint.messageFunction;
   return pureConstraint;
@@ -133,19 +139,22 @@ export const V1_buildUnit = (
     unit.name,
     parentMeasure,
     unit.conversionFunction
-      ? V1_resolvePathsInRawLambda(
-          context,
+      ? V1_buildRawLambdaWithResolvedPaths(
           unit.conversionFunction.parameters,
           unit.conversionFunction.body,
+          context,
         )
       : undefined,
   );
-  const path = currentGraph.buildPath(unit.package, unit.name);
+  const path = V1_buildFullPath(unit.package, unit.name);
   assertTrue(
     !currentGraph.getOwnNullableElement(path),
     `Element '${path}' already exists`,
   );
-  _package_addElement(currentGraph.getOrCreatePackage(unit.package), pureUnit);
+  addElementToPackage(
+    getOrCreateGraphPackage(currentGraph, unit.package, undefined),
+    pureUnit,
+  );
   currentGraph.setOwnType(path, pureUnit);
   return pureUnit;
 };
@@ -218,10 +227,10 @@ export const V1_buildDerivedProperty = (
   derivedProperty.taggedValues = property.taggedValues
     .map((taggedValue) => V1_buildTaggedValue(taggedValue, context))
     .filter(isNonNullable);
-  const rawLambda = V1_resolvePathsInRawLambda(
-    context,
+  const rawLambda = V1_buildRawLambdaWithResolvedPaths(
     property.parameters,
     property.body,
+    context,
   );
   derivedProperty.body = rawLambda.body;
   derivedProperty.parameters = rawLambda.parameters;

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

@@ -64,7 +64,7 @@ import { V1_ObjectInputData } from '../../../../model/packageableElements/store/
 import { V1_FlatDataInputData } from '../../../../model/packageableElements/store/flatData/mapping/V1_FlatDataInputData';
 import type { V1_ClassMapping } from '../../../../model/packageableElements/mapping/V1_ClassMapping';
 import type { V1_MappingInclude } from '../../../../model/packageableElements/mapping/V1_MappingInclude';
-import { V1_resolvePathsInRawLambda } from './V1_ValueSpecificationPathResolver';
+import { V1_buildRawLambdaWithResolvedPaths } from './V1_ValueSpecificationPathResolver';
 import { V1_RelationalInputData } from '../../../../model/packageableElements/store/relational/mapping/V1_RelationalInputData';
 import {
   getRelationalInputType,
@@ -269,10 +269,10 @@ export const V1_buildMappingTest = (
     `Mapping test 'name' field is missing or empty`,
   );
   assertNonNullable(mappingTest.query, `Mapping test 'query' field is missing`);
-  const query = V1_resolvePathsInRawLambda(
-    context,
+  const query = V1_buildRawLambdaWithResolvedPaths(
     mappingTest.query.parameters,
     mappingTest.query.body,
+    context,
   );
   // TODO: fix this when we support another mapping test type
   assertType(

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

@@ -0,0 +1,192 @@
+/**
+ * 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 } from '@finos/legend-shared';
+import type { PureModel } from '../../../../../../../../graph/PureModel';
+import { getMilestoneTemporalStereotype } from '../../../../../../../../helpers/DomainHelper';
+import {
+  DEFAULT_PROCESSING_DATE_MILESTONING_PARAMETER_NAME,
+  MILESTONING_END_DATE_PARAMETER_NAME,
+  MILESTONING_VERSION_PROPERTY_SUFFIX,
+  MILESTONING_STEREOTYPE,
+  PRIMITIVE_TYPE,
+  MILESTONING_START_DATE_PARAMETER_NAME,
+  DEFAULT_BUSINESS_DATE_MILESTONING_PARAMETER_NAME,
+} from '../../../../../../../../MetaModelConst';
+import type { PropertyOwner } from '../../../../../../../metamodels/pure/packageableElements/domain/AbstractProperty';
+import { Class } from '../../../../../../../metamodels/pure/packageableElements/domain/Class';
+import { DerivedProperty } from '../../../../../../../metamodels/pure/packageableElements/domain/DerivedProperty';
+import { GenericType } from '../../../../../../../metamodels/pure/packageableElements/domain/GenericType';
+import { GenericTypeExplicitReference } from '../../../../../../../metamodels/pure/packageableElements/domain/GenericTypeReference';
+import { Multiplicity } from '../../../../../../../metamodels/pure/packageableElements/domain/Multiplicity';
+import { Property } from '../../../../../../../metamodels/pure/packageableElements/domain/Property';
+import { V1_Multiplicity } from '../../../../model/packageableElements/domain/V1_Multiplicity';
+import type { V1_ValueSpecification } from '../../../../model/valueSpecification/V1_ValueSpecification';
+import { V1_Variable } from '../../../../model/valueSpecification/V1_Variable';
+import { V1_serializeValueSpecification } from '../../../pureProtocol/serializationHelpers/V1_ValueSpecificationSerializer';
+
+const buildMilestoningParameter = (
+  parameterName: string,
+): PlainObject<V1_ValueSpecification> => {
+  const milestoningParameter = new V1_Variable();
+  milestoningParameter.name = parameterName;
+  const multiplicity = new V1_Multiplicity();
+  multiplicity.lowerBound = 1;
+  multiplicity.upperBound = 1;
+  milestoningParameter.multiplicity = multiplicity;
+  milestoningParameter.class = PRIMITIVE_TYPE.DATE;
+  const json = V1_serializeValueSpecification(milestoningParameter);
+  return json;
+};
+
+/**
+ * Builds abstract properties `allVersions`, `allVersionsInRange` and derived property with date parameter
+ * while processing the milestoning properties of a class or association.
+ */
+export const V1_buildMilestoningProperties = (
+  propertyOwner: PropertyOwner,
+  graph: PureModel,
+): void => {
+  propertyOwner.properties.forEach((property) => {
+    if (property.genericType.value.rawType instanceof Class) {
+      const milestonedStereotype = getMilestoneTemporalStereotype(
+        property.genericType.value.rawType,
+        graph,
+      );
+      switch (milestonedStereotype) {
+        case MILESTONING_STEREOTYPE.BUSINESS_TEMPORAL: {
+          const dateProperty = new DerivedProperty(
+            property.name,
+            property.multiplicity,
+            GenericTypeExplicitReference.create(
+              new GenericType(property.genericType.value.rawType),
+            ),
+            property.owner,
+          );
+          dateProperty.parameters = [
+            buildMilestoningParameter(
+              DEFAULT_BUSINESS_DATE_MILESTONING_PARAMETER_NAME,
+            ),
+          ];
+          const milestonedAllVersions = new Property(
+            `${property.name}${MILESTONING_VERSION_PROPERTY_SUFFIX.ALL_VERSIONS}`,
+            new Multiplicity(property.multiplicity.lowerBound, undefined),
+            GenericTypeExplicitReference.create(
+              new GenericType(property.genericType.value.rawType),
+            ),
+            property.owner,
+          );
+          const milestonedAllVersionsInRange = new DerivedProperty(
+            `${property.name}${MILESTONING_VERSION_PROPERTY_SUFFIX.ALL_VERSIONS_IN_RANGE}`,
+            property.multiplicity,
+            GenericTypeExplicitReference.create(
+              new GenericType(property.genericType.value.rawType),
+            ),
+            property.owner,
+          );
+          milestonedAllVersionsInRange.parameters = [
+            buildMilestoningParameter(MILESTONING_START_DATE_PARAMETER_NAME),
+            buildMilestoningParameter(MILESTONING_END_DATE_PARAMETER_NAME),
+          ];
+          propertyOwner._generatedMilestonedProperties.push(dateProperty);
+          propertyOwner._generatedMilestonedProperties.push(
+            milestonedAllVersions,
+          );
+          propertyOwner._generatedMilestonedProperties.push(
+            milestonedAllVersionsInRange,
+          );
+          break;
+        }
+        case MILESTONING_STEREOTYPE.PROCESSING_TEMPORAL: {
+          const dateProperty = new DerivedProperty(
+            property.name,
+            property.multiplicity,
+            GenericTypeExplicitReference.create(
+              new GenericType(property.genericType.value.rawType),
+            ),
+            property.owner,
+          );
+          dateProperty.parameters = [
+            buildMilestoningParameter(
+              DEFAULT_PROCESSING_DATE_MILESTONING_PARAMETER_NAME,
+            ),
+          ];
+          const milestonedAllVersions = new Property(
+            `${property.name}${MILESTONING_VERSION_PROPERTY_SUFFIX.ALL_VERSIONS}`,
+            new Multiplicity(property.multiplicity.lowerBound, undefined),
+            GenericTypeExplicitReference.create(
+              new GenericType(property.genericType.value.rawType),
+            ),
+            property.owner,
+          );
+          const milestonedAllVersionsInRange = new DerivedProperty(
+            `${property.name}${MILESTONING_VERSION_PROPERTY_SUFFIX.ALL_VERSIONS_IN_RANGE}`,
+            property.multiplicity,
+            GenericTypeExplicitReference.create(
+              new GenericType(property.genericType.value.rawType),
+            ),
+            property.owner,
+          );
+          milestonedAllVersionsInRange.parameters = [
+            buildMilestoningParameter(MILESTONING_START_DATE_PARAMETER_NAME),
+            buildMilestoningParameter(MILESTONING_END_DATE_PARAMETER_NAME),
+          ];
+          propertyOwner._generatedMilestonedProperties.push(dateProperty);
+          propertyOwner._generatedMilestonedProperties.push(
+            milestonedAllVersions,
+          );
+          propertyOwner._generatedMilestonedProperties.push(
+            milestonedAllVersionsInRange,
+          );
+          break;
+        }
+        case MILESTONING_STEREOTYPE.BITEMPORAL: {
+          const dateProperty = new DerivedProperty(
+            property.name,
+            property.multiplicity,
+            GenericTypeExplicitReference.create(
+              new GenericType(property.genericType.value.rawType),
+            ),
+            property.owner,
+          );
+          dateProperty.parameters = [
+            buildMilestoningParameter(
+              DEFAULT_PROCESSING_DATE_MILESTONING_PARAMETER_NAME,
+            ),
+            buildMilestoningParameter(
+              DEFAULT_BUSINESS_DATE_MILESTONING_PARAMETER_NAME,
+            ),
+          ];
+          const milestonedAllVersions = new Property(
+            `${property.name}${MILESTONING_VERSION_PROPERTY_SUFFIX.ALL_VERSIONS}`,
+            new Multiplicity(property.multiplicity.lowerBound, undefined),
+            GenericTypeExplicitReference.create(
+              new GenericType(property.genericType.value.rawType),
+            ),
+            property.owner,
+          );
+          propertyOwner._generatedMilestonedProperties.push(dateProperty);
+          propertyOwner._generatedMilestonedProperties.push(
+            milestonedAllVersions,
+          );
+          break;
+        }
+        default:
+          break;
+      }
+    }
+  });
+};

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

@@ -29,7 +29,7 @@ import { V1_ProcessingMilestoning } from '../../../../model/packageableElements/
 import { ProcessingMilestoning } from '../../../../../../../metamodels/pure/packageableElements/store/relational/model/milestoning/ProcessingMilestoning';
 import type { V1_GraphBuilderContext } from '../V1_GraphBuilderContext';
 import type { StoreRelational_PureProtocolProcessorPlugin_Extension } from '../../../../../StoreRelational_PureProtocolProcessorPlugin_Extension';
-import { RawInstanceValue } from '../../../../../../../metamodels/pure/rawValueSpecification/RawInstanceValue';
+import { RawPrimitiveInstanceValue } from '../../../../../../../metamodels/pure/rawValueSpecification/RawPrimitiveInstanceValue';
 import { V1_ProtocolToMetaModelRawValueSpecificationBuilder } from '../V1_ProtocolToMetaModelRawValueSpecificationBuilder';
 
 const buildBusinessMilesoning = (
@@ -54,7 +54,7 @@ const buildBusinessMilesoning = (
       protocol.infinityDate.accept_RawValueSpecificationVisitor(
         new V1_ProtocolToMetaModelRawValueSpecificationBuilder(context),
       ),
-      RawInstanceValue,
+      RawPrimitiveInstanceValue,
     );
   }
   return metamodel;
@@ -74,7 +74,7 @@ const buildBusinessSnapshotMilestoning = (
       protocol.infinityDate.accept_RawValueSpecificationVisitor(
         new V1_ProtocolToMetaModelRawValueSpecificationBuilder(context),
       ),
-      RawInstanceValue,
+      RawPrimitiveInstanceValue,
     );
   }
   return metamodel;
@@ -102,7 +102,7 @@ const buildProcessingMilestoning = (
       protocol.infinityDate.accept_RawValueSpecificationVisitor(
         new V1_ProtocolToMetaModelRawValueSpecificationBuilder(context),
       ),
-      RawInstanceValue,
+      RawPrimitiveInstanceValue,
     );
   }
   return metamodel;

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

@@ -27,7 +27,6 @@ import {
   DefaultCodeSection,
 } from '../../../../../../../metamodels/pure/packageableElements/section/Section';
 import type { SectionIndex } from '../../../../../../../metamodels/pure/packageableElements/section/SectionIndex';
-import { Package } from '../../../../../../../metamodels/pure/packageableElements/domain/Package';
 import { PackageableElementExplicitReference } from '../../../../../../../metamodels/pure/packageableElements/PackageableElementReference';
 import type { V1_GraphBuilderContext } from '../../../../transformation/pureGraph/to/V1_GraphBuilderContext';
 import {
@@ -37,42 +36,43 @@ import {
 } from '../../../../model/packageableElements/section/V1_Section';
 
 export const V1_buildSection = (
-  section: V1_Section,
+  protocol: V1_Section,
   context: V1_GraphBuilderContext,
   parentSectionIndex: SectionIndex,
 ): Section => {
-  let sec: Section;
-  if (section instanceof V1_ImportAwareCodeSection) {
+  let section: Section;
+
+  if (protocol instanceof V1_ImportAwareCodeSection) {
     const importAwareSection = new ImportAwareCodeSection(
-      section.parserName,
+      protocol.parserName,
       parentSectionIndex,
     );
-    importAwareSection.imports = uniq(section.imports)
+    importAwareSection.imports = uniq(protocol.imports)
       .map((_package) => {
-        const element = context.graph.getNullableElement(_package, true);
-        if (!(element instanceof Package)) {
+        const pkg = context.graph.getNullablePackage(_package);
+        if (!pkg) {
           context.log.warn(
             LogEvent.create(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_FAILURE),
             `Can't find section import package '${_package}'`,
           );
+          return undefined;
         }
-        return element instanceof Package
-          ? // NOTE: here we use explicit because this information from section
-            // must always be the package full path
-            PackageableElementExplicitReference.create(element)
-          : undefined;
+        // NOTE: here we use explicit because this information from section
+        // must always be the package full path
+        return PackageableElementExplicitReference.create(pkg);
       })
       .filter(isNonNullable);
-    sec = importAwareSection;
-  } else if (section instanceof V1_DefaultCodeSection) {
-    sec = new DefaultCodeSection(section.parserName, parentSectionIndex);
+    section = importAwareSection;
+  } else if (protocol instanceof V1_DefaultCodeSection) {
+    section = new DefaultCodeSection(protocol.parserName, parentSectionIndex);
   } else {
-    throw new UnsupportedOperationError(`Can't build section`, section);
+    throw new UnsupportedOperationError(`Can't build section`, protocol);
   }
+
   // NOTE: we ignore not-found element path and duplicated import packages, but we will prune them as well
-  sec.elements = uniq(section.elements)
+  section.elements = uniq(protocol.elements)
     .map((elementPath) => {
-      const element = context.graph.getNullableElement(elementPath);
+      const element = context.graph.getOwnNullableElement(elementPath);
       if (!element) {
         context.log.warn(
           LogEvent.create(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_FAILURE),
@@ -80,18 +80,18 @@ export const V1_buildSection = (
         );
         return element;
       }
-      if (context.graph.getOwnSection(element.path)) {
+      if (context.graph.getOwnNullableSection(element.path)) {
         context.log.warn(
           LogEvent.create(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_FAILURE),
           `Found duplicated section element '${elementPath}'`,
         );
       } else {
-        context.graph.setOwnSection(element.path, sec);
+        context.graph.setOwnSection(element.path, section);
       }
       // NOTE: here we use explicit because this information from section
       // must always be the full element path
       return PackageableElementExplicitReference.create(element);
     })
     .filter(isNonNullable);
-  return sec;
+  return section;
 };

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

@@ -27,13 +27,7 @@ import {
   RuntimePointer,
 } from '../../../../../../../metamodels/pure/packageableElements/runtime/Runtime';
 import type { Service } from '../../../../../../../metamodels/pure/packageableElements/service/Service';
-import {
-  type ServiceTest,
-  SingleExecutionTest,
-  MultiExecutionTest,
-  TestContainer,
-  KeyedSingleExecutionTest,
-} from '../../../../../../../metamodels/pure/packageableElements/service/ServiceTest';
+import { ServiceTest } from '../../../../../../../metamodels/pure/packageableElements/service/ServiceTest';
 import {
   type ServiceExecution,
   PureSingleExecution,
@@ -41,11 +35,7 @@ import {
   KeyedExecutionParameter,
 } from '../../../../../../../metamodels/pure/packageableElements/service/ServiceExecution';
 import type { V1_GraphBuilderContext } from '../../../../transformation/pureGraph/to/V1_GraphBuilderContext';
-import {
-  type V1_ServiceTest,
-  V1_SingleExecutionTest,
-  V1_MultiExecutionTest,
-} from '../../../../model/packageableElements/service/V1_ServiceTest';
+import type { V1_ServiceTest } from '../../../../model/packageableElements/service/V1_ServiceTest';
 import {
   type V1_ServiceExecution,
   V1_PureSingleExecution,
@@ -64,27 +54,114 @@ import {
   V1_PackageableElementPointer,
   V1_PackageableElementPointerType,
 } from '../../../../model/packageableElements/V1_PackageableElement';
-import { V1_resolvePathsInRawLambda } from './V1_ValueSpecificationPathResolver';
+import { V1_buildRawLambdaWithResolvedPaths } from './V1_ValueSpecificationPathResolver';
 import { GraphBuilderError } from '../../../../../../../../graphManager/GraphManagerUtils';
+import {
+  type DEPRECATED__ServiceTest,
+  DEPRECATED__KeyedSingleExecutionTest,
+  DEPRECATED__MultiExecutionTest,
+  DEPRECATED__SingleExecutionTest,
+  DEPRECATED__TestContainer,
+} from '../../../../../../../metamodels/pure/packageableElements/service/DEPRECATED__ServiceTest';
+import { ConnectionTestData } from '../../../../../../../metamodels/pure/packageableElements/service/ConnectionTestData';
+import { ParameterValue } from '../../../../../../../metamodels/pure/packageableElements/service/ParameterValue';
+import { ServiceTestSuite } from '../../../../../../../metamodels/pure/packageableElements/service/ServiceTestSuite';
+import { TestData } from '../../../../../../../metamodels/pure/packageableElements/service/ServiceTestData';
+import type { V1_ConnectionTestData } from '../../../../model/packageableElements/service/V1_ConnectionTestData';
+import type { V1_ParameterValue } from '../../../../model/packageableElements/service/V1_ParameterValue';
+import type { V1_ServiceTestSuite } from '../../../../model/packageableElements/service/V1_ServiceTestSuite';
+import type { V1_TestData } from '../../../../model/packageableElements/service/V1_TestData';
+import {
+  V1_buildTestAssertion,
+  V1_buildAtomicTest,
+} from './V1_TestBuilderHelper';
+import { V1_ProtocolToMetaModelEmbeddedDataBuilder } from './V1_DataElementBuilderHelper';
+import {
+  type V1_DEPRECATED__ServiceTest,
+  V1_DEPRECATED__SingleExecutionTest,
+  V1_DEPRECATED__MultiExecutionTest,
+} from '../../../../model/packageableElements/service/V1_DEPRECATED__ServiceTest';
+
+const buildConnectionTestData = (
+  element: V1_ConnectionTestData,
+  context: V1_GraphBuilderContext,
+): ConnectionTestData => {
+  const connectionTestData = new ConnectionTestData();
+  connectionTestData.connectionId = element.id;
+  connectionTestData.testData = element.data.accept_EmbeddedDataVisitor(
+    new V1_ProtocolToMetaModelEmbeddedDataBuilder(context),
+  );
+  return connectionTestData;
+};
+
+const buildParameterValue = (element: V1_ParameterValue): ParameterValue => {
+  const parameterValue = new ParameterValue();
+  parameterValue.name = element.name;
+  parameterValue.value = element.value;
+  return parameterValue;
+};
+
+const buildTestData = (
+  element: V1_TestData,
+  context: V1_GraphBuilderContext,
+): TestData => {
+  const testData = new TestData();
+  testData.connectionsTestData = element.connectionsTestData.map(
+    (connectionTestData) =>
+      buildConnectionTestData(connectionTestData, context),
+  );
+  return testData;
+};
 
 export const V1_buildServiceTest = (
-  serviceTest: V1_ServiceTest,
+  element: V1_ServiceTest,
   context: V1_GraphBuilderContext,
-  parentService: Service,
 ): ServiceTest => {
-  if (serviceTest instanceof V1_SingleExecutionTest) {
+  const serviceTest = new ServiceTest();
+  serviceTest.id = element.id;
+  serviceTest.parameters = element.parameters.map((parameter) =>
+    buildParameterValue(parameter),
+  );
+  serviceTest.assertions = element.assertions.map((assertion) =>
+    V1_buildTestAssertion(assertion, context),
+  );
+  return serviceTest;
+};
+
+export const V1_buildServiceTestSuite = (
+  element: V1_ServiceTestSuite,
+  context: V1_GraphBuilderContext,
+): ServiceTestSuite => {
+  const serviceTestSuite = new ServiceTestSuite();
+  serviceTestSuite.id = element.id;
+  serviceTestSuite.testData = buildTestData(element.testData, context);
+  serviceTestSuite.tests = element.tests.map((test) =>
+    V1_buildAtomicTest(test, context),
+  );
+  return serviceTestSuite;
+};
+
+export const V1_buildLegacyServiceTest = (
+  serviceTest: V1_DEPRECATED__ServiceTest,
+  context: V1_GraphBuilderContext,
+  parentService: Service,
+): DEPRECATED__ServiceTest => {
+  if (serviceTest instanceof V1_DEPRECATED__SingleExecutionTest) {
     assertType(
       parentService.execution,
       PureSingleExecution,
       'Service with single-execution requires a single-execution test',
     );
-    const singleTest = new SingleExecutionTest(parentService, serviceTest.data);
+    const singleTest = new DEPRECATED__SingleExecutionTest(
+      parentService,
+      serviceTest.data,
+    );
     singleTest.asserts = serviceTest.asserts.map((assert) => {
-      const testContainer = new TestContainer(
-        V1_resolvePathsInRawLambda(
-          context,
+      const testContainer = new DEPRECATED__TestContainer(
+        V1_buildRawLambdaWithResolvedPaths(
           assert.assert.parameters,
           assert.assert.body,
+          context,
         ),
         singleTest,
       );
@@ -92,13 +169,13 @@ export const V1_buildServiceTest = (
       return testContainer;
     });
     return singleTest;
-  } else if (serviceTest instanceof V1_MultiExecutionTest) {
+  } else if (serviceTest instanceof V1_DEPRECATED__MultiExecutionTest) {
     assertType(
       parentService.execution,
       PureMultiExecution,
       'Service with multi-execution requires a multi-execution test',
     );
-    const multiTest = new MultiExecutionTest(parentService);
+    const multiTest = new DEPRECATED__MultiExecutionTest(parentService);
     if (!serviceTest.tests.length) {
       throw new GraphBuilderError(
         'Service multi-execution test must not be empty',
@@ -122,17 +199,17 @@ export const V1_buildServiceTest = (
         );
       }
       uniqueKeys.add(test.key);
-      const keyedTest = new KeyedSingleExecutionTest(
+      const keyedTest = new DEPRECATED__KeyedSingleExecutionTest(
         test.key,
         parentService,
         test.data,
       );
       keyedTest.asserts = test.asserts.map((assert) => {
-        const testContaier = new TestContainer(
-          V1_resolvePathsInRawLambda(
-            context,
+        const testContaier = new DEPRECATED__TestContainer(
+          V1_buildRawLambdaWithResolvedPaths(
             assert.assert.parameters,
             assert.assert.body,
+            context,
           ),
           keyedTest,
         );
@@ -169,7 +246,11 @@ export const V1_buildServiceTest = (
       multiTest.tests = parentService.execution.executionParameters.map(
         (execution) =>
           multiTest.tests.find((test) => test.key === execution.key) ??
-          new KeyedSingleExecutionTest(execution.key, parentService, ''),
+          new DEPRECATED__KeyedSingleExecutionTest(
+            execution.key,
+            parentService,
+            '',
+          ),
       );
     } else if (testWithoutExecutionKeys.size) {
       throw new GraphBuilderError(
@@ -248,10 +329,10 @@ export const V1_buildServiceExecution = (
       `Service Pure execution 'func' field is missing`,
     );
     return new PureSingleExecution(
-      V1_resolvePathsInRawLambda(
-        context,
+      V1_buildRawLambdaWithResolvedPaths(
         serviceExecution.func.parameters,
         serviceExecution.func.body,
+        context,
       ),
       parentService,
       context.resolveMapping(serviceExecution.mapping),
@@ -275,10 +356,10 @@ export const V1_buildServiceExecution = (
     );
     const execution = new PureMultiExecution(
       serviceExecution.executionKey,
-      V1_resolvePathsInRawLambda(
-        context,
+      V1_buildRawLambdaWithResolvedPaths(
         serviceExecution.func.parameters,
         serviceExecution.func.body,
+        context,
       ),
       parentService,
     );