@finos/legend-graph 6.0.0 → 8.0.0

package/lib/models/protocols/pure/v1/V1_PureGraphManager.js

@@ -13,79 +13,85 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { GRAPH_MANAGER_EVENT } from '../../../../graphManager/GraphManagerEvent';
-import { CORE_PURE_PATH, ELEMENT_PATH_DELIMITER, SOURCE_INFORMATION_KEY, } from '../../../../MetaModelConst';
-import { TracerService, LogEvent, getClass, guaranteeNonNullable, UnsupportedOperationError, recursiveOmit, assertTrue, assertErrorThrown, promisify, StopWatch, assertNonEmptyString, filterByType, } from '@finos/legend-shared';
-import { AbstractPureGraphManager, } from '../../../../graphManager/AbstractPureGraphManager';
-import { Mapping } from '../../../metamodels/pure/packageableElements/mapping/Mapping';
-import { EngineRuntime, } from '../../../metamodels/pure/packageableElements/runtime/Runtime';
-import { PureModel, } from '../../../../graph/PureModel';
-import { RawLambda } from '../../../metamodels/pure/rawValueSpecification/RawLambda';
-import { ServiceExecutionMode } from '../../../../graphManager/action/service/ServiceExecutionMode';
-import { KeyedExecutionParameter, PureMultiExecution, PureSingleExecution, } from '../../../metamodels/pure/packageableElements/service/ServiceExecution';
-import { V1_deserializeRawValueSpecification, V1_serializeRawValueSpecification, } from './transformation/pureProtocol/serializationHelpers/V1_RawValueSpecificationSerializationHelper';
-import { V1_serializeValueSpecification, V1_deserializeValueSpecification, } from './transformation/pureProtocol/serializationHelpers/V1_ValueSpecificationSerializer';
+import { GRAPH_MANAGER_EVENT } from '../../../../graphManager/GraphManagerEvent.js';
+import { CORE_PURE_PATH, ELEMENT_PATH_DELIMITER, SOURCE_INFORMATION_KEY, PackageableElementPointerType, } from '../../../../MetaModelConst.js';
+import { TracerService, LogEvent, getClass, guaranteeNonNullable, UnsupportedOperationError, recursiveOmit, assertTrue, assertErrorThrown, promisify, StopWatch, filterByType, isNonNullable, guaranteeNonEmptyString, } from '@finos/legend-shared';
+import { AbstractPureGraphManager, } from '../../../../graphManager/AbstractPureGraphManager.js';
+import { Mapping } from '../../../metamodels/pure/packageableElements/mapping/Mapping.js';
+import { EngineRuntime, } from '../../../metamodels/pure/packageableElements/runtime/Runtime.js';
+import { PureModel, } from '../../../../graph/PureModel.js';
+import { RawLambda } from '../../../metamodels/pure/rawValueSpecification/RawLambda.js';
+import { ServiceExecutionMode } from '../../../../graphManager/action/service/ServiceExecutionMode.js';
+import { KeyedExecutionParameter, PureMultiExecution, PureSingleExecution, } from '../../../metamodels/pure/packageableElements/service/ServiceExecution.js';
+import { V1_deserializeRawValueSpecification, V1_serializeRawValueSpecification, } from './transformation/pureProtocol/serializationHelpers/V1_RawValueSpecificationSerializationHelper.js';
+import { V1_serializeValueSpecification, V1_deserializeValueSpecification, } from './transformation/pureProtocol/serializationHelpers/V1_ValueSpecificationSerializer.js';
 import V1_CORE_SYSTEM_MODELS from './V1_Core_SystemModels.json';
-import { V1_serializePackageableElement } from './transformation/pureProtocol/V1_PackageableElementSerialization';
-import { V1_entitiesToPureModelContextData, V1_serializePureModelContext, V1_deserializePureModelContextData, V1_setupPureModelContextDataSerialization, } from './transformation/pureProtocol/V1_PureProtocolSerialization';
-import { V1_PureModelContextData } from './model/context/V1_PureModelContextData';
-import { V1_PackageableElementPointerType, V1_PackageableElementPointer, } from './model/packageableElements/V1_PackageableElement';
-import { V1_ProtocolToMetaModelGraphFirstPassBuilder } from './transformation/pureGraph/to/V1_ProtocolToMetaModelGraphFirstPassBuilder';
-import { V1_ProtocolToMetaModelGraphSecondPassBuilder } from './transformation/pureGraph/to/V1_ProtocolToMetaModelGraphSecondPassBuilder';
-import { V1_ProtocolToMetaModelGraphThirdPassBuilder } from './transformation/pureGraph/to/V1_ProtocolToMetaModelGraphThirdPassBuilder';
-import { V1_ProtocolToMetaModelGraphFourthPassBuilder } from './transformation/pureGraph/to/V1_ProtocolToMetaModelGraphFourthPassBuilder';
-import { V1_ProtocolToMetaModelGraphFifthPassBuilder } from './transformation/pureGraph/to/V1_ProtocolToMetaModelGraphFifthPassBuilder';
-import { V1_ProtocolToMetaModelRawValueSpecificationBuilder } from './transformation/pureGraph/to/V1_ProtocolToMetaModelRawValueSpecificationBuilder';
-import { V1_RawBaseExecutionContext } from './model/rawValueSpecification/V1_RawExecutionContext';
-import { V1_GraphBuilderContextBuilder, } from './transformation/pureGraph/to/V1_GraphBuilderContext';
-import { V1_PureModelContextPointer } from './model/context/V1_PureModelContextPointer';
-import { V1_Engine } from './engine/V1_Engine';
-import { V1_transformPackageableElement } from './transformation/pureGraph/from/V1_PackageableElementTransformer';
-import { V1_transformRawLambda, V1_RawValueSpecificationTransformer, } from './transformation/pureGraph/from/V1_RawValueSpecificationTransformer';
-import { V1_transformRuntime } from './transformation/pureGraph/from/V1_RuntimeTransformer';
-import { V1_ExecuteInput, V1_TestDataGenerationExecutionInput, } from './engine/execution/V1_ExecuteInput';
-import { V1_buildValueSpecification } from './transformation/pureGraph/to/helpers/V1_ValueSpecificationBuilderHelper';
-import { V1_transformRootValueSpecification } from './transformation/pureGraph/from/V1_ValueSpecificationTransformer';
-import { V1_Profile } from './model/packageableElements/domain/V1_Profile';
-import { V1_Class } from './model/packageableElements/domain/V1_Class';
-import { V1_Enumeration } from './model/packageableElements/domain/V1_Enumeration';
-import { V1_Association } from './model/packageableElements/domain/V1_Association';
-import { V1_Measure } from './model/packageableElements/domain/V1_Measure';
-import { V1_Store } from './model/packageableElements/store/V1_Store';
-import { V1_Service } from './model/packageableElements/service/V1_Service';
-import { V1_PackageableRuntime } from './model/packageableElements/runtime/V1_PackageableRuntime';
-import { V1_PackageableConnection } from './model/packageableElements/connection/V1_PackageableConnection';
-import { V1_FileGenerationSpecification } from './model/packageableElements/fileGeneration/V1_FileGenerationSpecification';
-import { V1_SectionIndex } from './model/packageableElements/section/V1_SectionIndex';
-import { V1_GenerationSpecification } from './model/packageableElements/generationSpecification/V1_GenerationSpecification';
-import { V1_Mapping } from './model/packageableElements/mapping/V1_Mapping';
-import { V1_ConcreteFunctionDefinition } from './model/packageableElements/function/V1_ConcreteFunctionDefinition';
-import { V1_PureModelContextComposite } from './model/context/V1_PureModelContextComposite';
-import { V1_AlloySDLC } from './model/context/V1_SDLC';
-import { V1_Protocol } from './model/V1_Protocol';
-import { V1_GraphBuilderExtensions } from './transformation/pureGraph/to/V1_GraphBuilderExtensions';
-import { V1_DatabaseBuilderConfig, V1_DatabaseBuilderInput, V1_DatabasePattern, V1_setupDatabaseBuilderInputSerialization, V1_TargetDatabase, } from './engine/generation/V1_DatabaseBuilderInput';
-import { V1_transformRelationalDatabaseConnection } from './transformation/pureGraph/from/V1_ConnectionTransformer';
-import { V1_FlatData } from './model/packageableElements/store/flatData/model/V1_FlatData';
-import { V1_Database } from './model/packageableElements/store/relational/model/V1_Database';
-import { V1_setupDatabaseSerialization } from './transformation/pureProtocol/serializationHelpers/V1_DatabaseSerializationHelper';
-import { V1_PACKAGEABLE_RUNTIME_ELEMENT_PROTOCOL_TYPE, V1_setupEngineRuntimeSerialization, V1_setupLegacyRuntimeSerialization, } from './transformation/pureProtocol/serializationHelpers/V1_RuntimeSerializationHelper';
-import { V1_GraphTransformerContextBuilder } from './transformation/pureGraph/from/V1_GraphTransformerContext';
-import { V1_transformExecutionNode, V1_transformExecutionPlan, } from './transformation/pureGraph/from/executionPlan/V1_ExecutionPlanTransformer';
-import { V1_deserializeExecutionPlan, V1_serializeExecutionNode, V1_serializeExecutionPlan, } from './transformation/pureProtocol/serializationHelpers/executionPlan/V1_ExecutionPlanSerializationHelper';
-import { V1_buildExecutionPlan } from './transformation/pureGraph/to/V1_ExecutionPlanBuilder';
-import { V1_buildQuery, V1_buildServiceTestResult, V1_buildServiceRegistrationResult, V1_transformQuery, V1_buildGenerationOutput, V1_buildLightQuery, V1_transformQuerySearchSpecification, } from './engine/V1_EngineHelper';
-import { V1_buildExecutionResult } from './engine/V1_ExecutionHelper';
+import { V1_serializePackageableElement } from './transformation/pureProtocol/V1_PackageableElementSerialization.js';
+import { V1_entitiesToPureModelContextData, V1_serializePureModelContext, V1_deserializePureModelContextData, V1_setupPureModelContextDataSerialization, } from './transformation/pureProtocol/V1_PureProtocolSerialization.js';
+import { V1_PureModelContextData } from './model/context/V1_PureModelContextData.js';
+import { V1_PackageableElementPointer, } from './model/packageableElements/V1_PackageableElement.js';
+import { V1_ProtocolToMetaModelGraphFirstPassBuilder } from './transformation/pureGraph/to/V1_ProtocolToMetaModelGraphFirstPassBuilder.js';
+import { V1_ProtocolToMetaModelGraphSecondPassBuilder } from './transformation/pureGraph/to/V1_ProtocolToMetaModelGraphSecondPassBuilder.js';
+import { V1_ProtocolToMetaModelGraphThirdPassBuilder } from './transformation/pureGraph/to/V1_ProtocolToMetaModelGraphThirdPassBuilder.js';
+import { V1_ProtocolToMetaModelGraphFourthPassBuilder } from './transformation/pureGraph/to/V1_ProtocolToMetaModelGraphFourthPassBuilder.js';
+import { V1_ProtocolToMetaModelGraphFifthPassBuilder } from './transformation/pureGraph/to/V1_ProtocolToMetaModelGraphFifthPassBuilder.js';
+import { V1_ProtocolToMetaModelRawValueSpecificationBuilder } from './transformation/pureGraph/to/V1_ProtocolToMetaModelRawValueSpecificationBuilder.js';
+import { V1_RawBaseExecutionContext } from './model/rawValueSpecification/V1_RawExecutionContext.js';
+import { V1_GraphBuilderContextBuilder, } from './transformation/pureGraph/to/V1_GraphBuilderContext.js';
+import { V1_PureModelContextPointer } from './model/context/V1_PureModelContextPointer.js';
+import { V1_Engine } from './engine/V1_Engine.js';
+import { V1_transformPackageableElement } from './transformation/pureGraph/from/V1_PackageableElementTransformer.js';
+import { V1_transformRawLambda, V1_RawValueSpecificationTransformer, } from './transformation/pureGraph/from/V1_RawValueSpecificationTransformer.js';
+import { V1_transformRuntime } from './transformation/pureGraph/from/V1_RuntimeTransformer.js';
+import { V1_ExecuteInput, V1_TestDataGenerationExecutionInput, } from './engine/execution/V1_ExecuteInput.js';
+import { V1_buildValueSpecification } from './transformation/pureGraph/to/helpers/V1_ValueSpecificationBuilderHelper.js';
+import { V1_transformRootValueSpecification } from './transformation/pureGraph/from/V1_ValueSpecificationTransformer.js';
+import { V1_Profile } from './model/packageableElements/domain/V1_Profile.js';
+import { V1_Class } from './model/packageableElements/domain/V1_Class.js';
+import { V1_Enumeration } from './model/packageableElements/domain/V1_Enumeration.js';
+import { V1_Association } from './model/packageableElements/domain/V1_Association.js';
+import { V1_Measure } from './model/packageableElements/domain/V1_Measure.js';
+import { V1_Store } from './model/packageableElements/store/V1_Store.js';
+import { V1_Service } from './model/packageableElements/service/V1_Service.js';
+import { V1_PackageableRuntime } from './model/packageableElements/runtime/V1_PackageableRuntime.js';
+import { V1_PackageableConnection } from './model/packageableElements/connection/V1_PackageableConnection.js';
+import { V1_FileGenerationSpecification } from './model/packageableElements/fileGeneration/V1_FileGenerationSpecification.js';
+import { V1_SectionIndex } from './model/packageableElements/section/V1_SectionIndex.js';
+import { V1_GenerationSpecification } from './model/packageableElements/generationSpecification/V1_GenerationSpecification.js';
+import { V1_Mapping } from './model/packageableElements/mapping/V1_Mapping.js';
+import { V1_ConcreteFunctionDefinition } from './model/packageableElements/function/V1_ConcreteFunctionDefinition.js';
+import { V1_PureModelContextComposite } from './model/context/V1_PureModelContextComposite.js';
+import { V1_AlloySDLC } from './model/context/V1_SDLC.js';
+import { V1_Protocol } from './model/V1_Protocol.js';
+import { V1_GraphBuilderExtensions } from './transformation/pureGraph/to/V1_GraphBuilderExtensions.js';
+import { V1_DatabaseBuilderConfig, V1_DatabaseBuilderInput, V1_DatabasePattern, V1_setupDatabaseBuilderInputSerialization, V1_TargetDatabase, } from './engine/generation/V1_DatabaseBuilderInput.js';
+import { V1_transformRelationalDatabaseConnection } from './transformation/pureGraph/from/V1_ConnectionTransformer.js';
+import { V1_FlatData } from './model/packageableElements/store/flatData/model/V1_FlatData.js';
+import { V1_Database } from './model/packageableElements/store/relational/model/V1_Database.js';
+import { V1_setupDatabaseSerialization } from './transformation/pureProtocol/serializationHelpers/V1_DatabaseSerializationHelper.js';
+import { V1_PACKAGEABLE_RUNTIME_ELEMENT_PROTOCOL_TYPE, V1_setupEngineRuntimeSerialization, V1_setupLegacyRuntimeSerialization, } from './transformation/pureProtocol/serializationHelpers/V1_RuntimeSerializationHelper.js';
+import { V1_GraphTransformerContextBuilder } from './transformation/pureGraph/from/V1_GraphTransformerContext.js';
+import { V1_transformExecutionNode, V1_transformExecutionPlan, } from './transformation/pureGraph/from/executionPlan/V1_ExecutionPlanTransformer.js';
+import { V1_deserializeExecutionPlan, V1_serializeExecutionNode, V1_serializeExecutionPlan, } from './transformation/pureProtocol/serializationHelpers/executionPlan/V1_ExecutionPlanSerializationHelper.js';
+import { V1_buildExecutionPlan } from './transformation/pureGraph/to/V1_ExecutionPlanBuilder.js';
+import { V1_buildQuery, V1_buildLegacyServiceTestResult, V1_buildServiceRegistrationResult, V1_transformQuery, V1_buildGenerationOutput, V1_buildLightQuery, V1_transformQuerySearchSpecification, } from './engine/V1_EngineHelper.js';
+import { V1_buildExecutionResult } from './engine/V1_ExecutionHelper.js';
 import { ENTITY_PATH_DELIMITER, } from '@finos/legend-model-storage';
-import { DependencyGraphBuilderError, GraphBuilderError, SystemGraphBuilderError, } from '../../../../graphManager/GraphManagerUtils';
-import { PackageableElementExplicitReference, PackageableElementReference, } from '../../../metamodels/pure/packageableElements/PackageableElementReference';
-import { V1_ExternalFormatModelGenerationInput } from './engine/externalFormat/V1_ExternalFormatModelGeneration';
-import { GraphBuilderReport } from '../../../../graphManager/GraphBuilderReport';
-import { V1_PureMultiExecution, V1_PureSingleExecution, } from './model/packageableElements/service/V1_ServiceExecution';
-import { V1_MAPPING_ELEMENT_PROTOCOL_TYPE } from './transformation/pureProtocol/serializationHelpers/V1_MappingSerializationHelper';
-import { V1_SERVICE_ELEMENT_PROTOCOL_TYPE } from './transformation/pureProtocol/serializationHelpers/V1_ServiceSerializationHelper';
-import { MappingInclude } from '../../../metamodels/pure/packageableElements/mapping/MappingInclude';
-import { V1_DataElement } from './model/packageableElements/data/V1_DataElement';
+import { DependencyGraphBuilderError, GraphBuilderError, SystemGraphBuilderError, } from '../../../../graphManager/GraphManagerUtils.js';
+import { PackageableElementExplicitReference, PackageableElementReference, } from '../../../metamodels/pure/packageableElements/PackageableElementReference.js';
+import { V1_ExternalFormatModelGenerationInput } from './engine/externalFormat/V1_ExternalFormatModelGeneration.js';
+import { GraphBuilderReport } from '../../../../graphManager/GraphBuilderReport.js';
+import { V1_PureMultiExecution, V1_PureSingleExecution, } from './model/packageableElements/service/V1_ServiceExecution.js';
+import { V1_MAPPING_ELEMENT_PROTOCOL_TYPE } from './transformation/pureProtocol/serializationHelpers/V1_MappingSerializationHelper.js';
+import { V1_SERVICE_ELEMENT_PROTOCOL_TYPE } from './transformation/pureProtocol/serializationHelpers/V1_ServiceSerializationHelper.js';
+import { MappingInclude } from '../../../metamodels/pure/packageableElements/mapping/MappingInclude.js';
+import { V1_DataElement } from './model/packageableElements/data/V1_DataElement.js';
+import { V1_RunTestsInput, V1_RunTestsTestableInput, } from './engine/test/V1_RunTestsInput.js';
+import { V1_AtomicTestId } from './model/test/V1_AtomicTestId.js';
+import { V1_buildTestsResult } from './engine/test/V1_RunTestsResult.js';
+import { stub_RawLambda } from '../../../../graphManager/action/creation/RawValueSpecificationCreatorHelper.js';
+import { getNullableIDFromTestable, getNullableTestable, } from '../../../../helpers/Testable_Helper.js';
+import { V1_getIncludedMappingPath } from './helper/V1_DSLMapping_Helper.js';
 const V1_FUNCTION_SUFFIX_MULTIPLICITY_INFINITE = 'MANY';
 const getMultiplicitySuffix = (multiplicity) => {
     if (multiplicity.lowerBound === multiplicity.upperBound) {
@@ -260,16 +266,15 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         await this.engine.setup(config);
     }
     // --------------------------------------------- Graph Builder ---------------------------------------------
-    async buildSystem(coreModel, systemModel, options) {
+    async buildSystem(coreModel, systemModel, buildState, options) {
         const stopWatch = new StopWatch();
         const report = new GraphBuilderReport();
-        const graphBuilderState = systemModel.buildState;
-        graphBuilderState.reset();
+        buildState.reset();
         // Create a dummy graph for system processing. This is to ensure system model does not depend on the main graph
         const graph = new PureModel(coreModel, systemModel, this.pluginManager.getPureGraphPlugins());
         try {
             // deserialize
-            graphBuilderState.setMessage(`Collecting and deserializing elements...`);
+            buildState.setMessage(`Collecting and deserializing elements...`);
             const systemData = mergePureModelContextData(V1_deserializePureModelContextData(V1_CORE_SYSTEM_MODELS), ...this.pluginManager
                 .getPureProtocolProcessorPlugins()
                 .flatMap((plugin) => plugin.V1_getExtraSystemModels?.() ?? [])
@@ -283,8 +288,8 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
                 },
             ];
             // build
-            await this.buildGraphFromInputs(graph, buildInputs, report, stopWatch, graphBuilderState, options);
-            graphBuilderState.pass();
+            await this.buildGraphFromInputs(graph, buildInputs, report, stopWatch, buildState, options);
+            buildState.pass();
             report.timings = {
                 ...Object.fromEntries(stopWatch.records),
                 [GRAPH_MANAGER_EVENT.GRAPH_BUILDER_COMPLETED]: stopWatch.elapsed,
@@ -293,26 +298,25 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         }
         catch (error) {
             assertErrorThrown(error);
-            graphBuilderState.fail();
+            buildState.fail();
             this.log.error(LogEvent.create(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_FAILURE), error);
             throw new SystemGraphBuilderError(error);
         }
         finally {
-            graphBuilderState.setMessage(undefined);
+            buildState.setMessage(undefined);
         }
     }
-    async buildDependencies(coreModel, systemModel, dependencyManager, dependencyEntitiesMap, options) {
+    async buildDependencies(coreModel, systemModel, dependencyManager, dependencyEntitiesMap, buildState, options) {
         const stopWatch = new StopWatch();
         const report = new GraphBuilderReport();
-        const graphBuilderState = dependencyManager.buildState;
-        graphBuilderState.reset();
+        buildState.reset();
         // Create a dummy graph for system processing. This is to ensure dependency models do not depend on the main graph
         const graph = new PureModel(coreModel, systemModel, this.pluginManager.getPureGraphPlugins());
         graph.dependencyManager = dependencyManager;
         try {
             dependencyManager.initialize(dependencyEntitiesMap);
             // deserialize
-            graphBuilderState.setMessage(`Partitioning and deserializing elements...`);
+            buildState.setMessage(`Partitioning and deserializing elements...`);
             const dependencyDataMap = new Map();
             await Promise.all(Array.from(dependencyEntitiesMap.entries()).map(([dependencyKey, entities]) => {
                 const projectModelData = new V1_PureModelContextData();
@@ -326,8 +330,8 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
                 data: indexPureModelContextData(report, dependencyData, this.extensions),
             }));
             // build
-            await this.buildGraphFromInputs(graph, buildInputs, report, stopWatch, graphBuilderState, options);
-            graphBuilderState.pass();
+            await this.buildGraphFromInputs(graph, buildInputs, report, stopWatch, buildState, options);
+            buildState.pass();
             report.otherStats.projectCount = dependencyEntitiesMap.size;
             report.timings = {
                 ...Object.fromEntries(stopWatch.records),
@@ -338,21 +342,20 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         catch (error) {
             assertErrorThrown(error);
             this.log.error(LogEvent.create(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_FAILURE), error);
-            graphBuilderState.fail();
+            buildState.fail();
             throw new DependencyGraphBuilderError(error);
         }
         finally {
-            graphBuilderState.setMessage(undefined);
+            buildState.setMessage(undefined);
         }
     }
-    async buildGraph(graph, entities, options) {
+    async buildGraph(graph, entities, buildState, options) {
         const stopWatch = new StopWatch();
         const report = new GraphBuilderReport();
-        const graphBuilderState = graph.buildState;
-        graphBuilderState.reset();
+        buildState.reset();
         try {
             // deserialize
-            graphBuilderState.setMessage(`Deserializing elements...`);
+            buildState.setMessage(`Deserializing elements...`);
             const data = new V1_PureModelContextData();
             await V1_entitiesToPureModelContextData(entities, data, this.pluginManager.getPureProtocolProcessorPlugins());
             stopWatch.record(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_ELEMENTS_DESERIALIZED);
@@ -364,7 +367,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
                 },
             ];
             // build
-            await this.buildGraphFromInputs(graph, buildInputs, report, stopWatch, graphBuilderState, options);
+            await this.buildGraphFromInputs(graph, buildInputs, report, stopWatch, buildState, options);
             /**
              * For now, we delete the section index. We are able to read both resolved and unresolved element paths
              * but when we write (serialize) we write only resolved paths. In the future once the issue with dependency is solved we will
@@ -373,7 +376,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
             if (!options?.TEMPORARY__preserveSectionIndex) {
                 graph.TEMPORARY__deleteOwnSectionIndex();
             }
-            graphBuilderState.pass();
+            buildState.pass();
             report.timings = {
                 ...Object.fromEntries(stopWatch.records),
                 [GRAPH_MANAGER_EVENT.GRAPH_BUILDER_COMPLETED]: stopWatch.elapsed,
@@ -383,7 +386,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         catch (error) {
             assertErrorThrown(error);
             this.log.error(LogEvent.create(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_FAILURE), error);
-            graphBuilderState.fail();
+            buildState.fail();
             /**
              * Wrap all error with `GraphBuilderError`, as we throw a lot of assertion error in the graph builder
              * But we might want to rethink this decision in the future and throw appropriate type of error
@@ -393,18 +396,17 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
                 : new GraphBuilderError(error);
         }
         finally {
-            graphBuilderState.setMessage(undefined);
+            buildState.setMessage(undefined);
         }
     }
-    async buildGenerations(graph, generatedEntities, options) {
+    async buildGenerations(graph, generatedEntities, buildState, options) {
         const stopWatch = new StopWatch();
         const report = new GraphBuilderReport();
         const generatedModel = graph.generationModel;
-        const graphBuilderState = generatedModel.buildState;
-        graphBuilderState.reset();
+        buildState.reset();
         try {
             // deserialize
-            graphBuilderState.setMessage(`Deserializing elements...`);
+            buildState.setMessage(`Deserializing elements...`);
             const generatedDataMap = new Map();
             await Promise.all(Array.from(generatedEntities.entries()).map(([generationParentPath, entities]) => {
                 const generatedData = new V1_PureModelContextData();
@@ -418,8 +420,8 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
                 data: indexPureModelContextData(report, generatedData, this.extensions),
             }));
             // build
-            await this.buildGraphFromInputs(graph, buildInputs, report, stopWatch, graphBuilderState, options);
-            graphBuilderState.pass();
+            await this.buildGraphFromInputs(graph, buildInputs, report, stopWatch, buildState, options);
+            buildState.pass();
             report.otherStats.generationCount = generatedDataMap.size;
             report.timings = {
                 ...Object.fromEntries(stopWatch.records),
@@ -430,7 +432,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         catch (error) {
             assertErrorThrown(error);
             this.log.error(LogEvent.create(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_FAILURE), error);
-            graphBuilderState.fail();
+            buildState.fail();
             /**
              * Wrap all error with `GraphBuilderError`, as we throw a lot of assertion error in the graph builder
              * But we might want to rethink this decision in the future and throw appropriate type of error
@@ -440,7 +442,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
                 : new GraphBuilderError(error);
         }
         finally {
-            graphBuilderState.setMessage(undefined);
+            buildState.setMessage(undefined);
         }
     }
     async buildGraphFromInputs(graph, inputs, report, stopWatch, graphBuilderState, options) {
@@ -596,17 +598,15 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
             !(el instanceof V1_SectionIndex));
         return this.pureModelContextDataToEntities(pmcd);
     }
-    async pureCodeToLambda(lambda, lambdaId = 'stub_lambdaId') {
+    async pureCodeToLambda(lambda, lambdaId) {
         const result = await this.engine.transformCodeToLambda(lambda, lambdaId);
-        return result ? new RawLambda(result.parameters, result.body) : undefined;
+        return new RawLambda(result.parameters, result.body);
     }
-    async lambdaToPureCode(lambda, lambdaId = 'stub_lambdaId', pretty) {
-        const lambdas = new Map();
-        lambdas.set(lambdaId, lambda);
-        return guaranteeNonNullable((await this.lambdasToPureCode(lambdas, pretty)).get(lambdaId));
+    async lambdaToPureCode(lambda, pretty) {
+        return this.engine.transformLambdaToCode(lambda, Boolean(pretty), this.pluginManager.getPureProtocolProcessorPlugins());
     }
     lambdasToPureCode(lambdas, pretty) {
-        return this.engine.transformLambdasToCode(lambdas, this.pluginManager.getPureProtocolProcessorPlugins(), pretty);
+        return this.engine.transformLambdasToCode(lambdas, Boolean(pretty), this.pluginManager.getPureProtocolProcessorPlugins());
     }
     pureCodeToRelationalOperationElement(operation, operationId) {
         return this.engine.transformPureCodeToRelationalOperationElement(operation, operationId);
@@ -680,6 +680,31 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         }
         return this.pureModelContextDataToEntities(generatedModel);
     }
+    // ------------------------------------------- Test  -------------------------------------------
+    async runTests(inputs, graph) {
+        const runTestsInput = new V1_RunTestsInput();
+        runTestsInput.model = this.getFullGraphModelData(graph);
+        runTestsInput.testables = inputs
+            .map((input) => {
+            const testable = guaranteeNonNullable(getNullableIDFromTestable(input.testable, graph, this.pluginManager.getPureGraphManagerPlugins()));
+            if (!testable) {
+                return undefined;
+            }
+            const runTestableInput = new V1_RunTestsTestableInput();
+            runTestableInput.testable = testable;
+            runTestableInput.unitTestIds = input.unitTestIds.map((unit) => {
+                const unitAtomicTest = new V1_AtomicTestId();
+                unitAtomicTest.testSuiteId = unit.parentSuite?.id;
+                unitAtomicTest.atomicTestId = unit.atomicTest.id;
+                return unitAtomicTest;
+            });
+            return runTestableInput;
+        })
+            .filter(isNonNullable);
+        const runTestsResult = await this.engine.runTests(runTestsInput);
+        const result = V1_buildTestsResult(runTestsResult, (id) => getNullableTestable(id, graph, this.pluginManager.getPureGraphManagerPlugins()));
+        return result;
+    }
     // ------------------------------------------- ValueSpecification -------------------------------------------
     buildValueSpecification(json, graph) {
         return V1_buildValueSpecification(V1_deserializeValueSpecification(json), new V1_GraphBuilderContextBuilder(graph, graph, this.extensions, this.log).build());
@@ -813,14 +838,14 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         return V1_serializeExecutionNode(V1_transformExecutionNode(executionNode, new V1_GraphTransformerContextBuilder(this.pluginManager.getPureProtocolProcessorPlugins()).build()));
     }
     // --------------------------------------------- Service ---------------------------------------------
-    async runServiceTests(service, graph) {
+    async runLegacyServiceTests(service, graph) {
         const protocolGraph = this.getFullGraphModelData(graph);
         const targetService = guaranteeNonNullable(protocolGraph.elements
             .filter(filterByType(V1_Service))
             .find((element) => element.path === service.path), `Can't run service test: service '${service.path}' not found`);
         protocolGraph.elements = protocolGraph.elements.filter((element) => !(element instanceof V1_Service));
         protocolGraph.elements.push(targetService);
-        return (await this.engine.runServiceTests(protocolGraph)).map(V1_buildServiceTestResult);
+        return (await this.engine.runLegacyServiceTests(protocolGraph)).map(V1_buildLegacyServiceTestResult);
     }
     async registerService(graph, service, groupdId, artifactId, server, executionMode, version) {
         const serverServiceInfo = await this.engine.getServerServiceInfo();
@@ -847,12 +872,12 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
                 const execution = service.execution;
                 if (execution instanceof PureSingleExecution) {
                     sdlcInfo.packageableElementPointers = [
-                        new V1_PackageableElementPointer(V1_PackageableElementPointerType.MAPPING, execution.mapping.value.path),
+                        new V1_PackageableElementPointer(PackageableElementPointerType.MAPPING, execution.mapping.value.path),
                     ];
                 }
                 else if (execution instanceof PureMultiExecution) {
                     sdlcInfo.packageableElementPointers =
-                        execution.executionParameters.map((e) => new V1_PackageableElementPointer(V1_PackageableElementPointerType.MAPPING, e.mapping.value.path));
+                        execution.executionParameters.map((e) => new V1_PackageableElementPointer(PackageableElementPointerType.MAPPING, e.mapping.value.path));
                 }
                 else {
                     throw new UnsupportedOperationError(`Can't register service with the specified execution`, execution);
@@ -865,7 +890,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
                 const sdlcInfo = new V1_AlloySDLC(groupdId, artifactId, version);
                 const pointer = new V1_PureModelContextPointer(protocol, sdlcInfo);
                 sdlcInfo.packageableElementPointers = [
-                    new V1_PackageableElementPointer(V1_PackageableElementPointerType.SERVICE, service.path),
+                    new V1_PackageableElementPointer(PackageableElementPointerType.SERVICE, service.path),
                 ];
                 input = pointer;
                 break;
@@ -954,10 +979,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
             v1Mappings.forEach((element) => {
                 const mapping = mappings.find((e) => e.path === element.path);
                 if (mapping) {
-                    mapping.includes = element.includedMappings.map((i) => {
-                        assertNonEmptyString(i.includedMappingPath, `Mapping include 'includedMappingPath' field is missing or empty`);
-                        return new MappingInclude(mapping, context.resolveMapping(i.includedMappingPath));
-                    });
+                    mapping.includes = element.includedMappings.map((i) => new MappingInclude(mapping, context.resolveMapping(guaranteeNonEmptyString(V1_getIncludedMappingPath(i), `Mapping include path is missing or empty`))));
                 }
             });
             // handle runtimes
@@ -976,11 +998,9 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
                     runtimeValue.mappings = element.runtimeValue.mappings.map((mapping) => context.resolveMapping(mapping.path));
                 }
             });
-            graph.buildState.pass();
         }
         catch (error) {
             assertErrorThrown(error);
-            graph.buildState.fail();
             /**
              * Wrap all error with `GraphBuilderError`, as we throw a lot of assertion error in the graph builder
              * But we might want to rethink this decision in the future and throw appropriate type of error
@@ -1010,21 +1030,19 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
                 if (service) {
                     const serviceExecution = element.execution;
                     if (serviceExecution instanceof V1_PureMultiExecution) {
-                        const execution = new PureMultiExecution(serviceExecution.executionKey, RawLambda.createStub(), service);
+                        const execution = new PureMultiExecution(serviceExecution.executionKey, stub_RawLambda(), service);
                         execution.executionParameters =
                             serviceExecution.executionParameters.map((keyedExecutionParameter) => new KeyedExecutionParameter(keyedExecutionParameter.key, PackageableElementExplicitReference.create(new Mapping('')), new EngineRuntime()));
                         service.execution = execution;
                     }
                     else if (serviceExecution instanceof V1_PureSingleExecution) {
-                        service.execution = new PureSingleExecution(RawLambda.createStub(), service, PackageableElementExplicitReference.create(new Mapping('')), new EngineRuntime());
+                        service.execution = new PureSingleExecution(stub_RawLambda(), service, PackageableElementExplicitReference.create(new Mapping('')), new EngineRuntime());
                     }
                 }
             });
-            graph.buildState.pass();
         }
         catch (error) {
             assertErrorThrown(error);
-            graph.buildState.fail();
             /**
              * Wrap all error with `GraphBuilderError`, as we throw a lot of assertion error in the graph builder
              * But we might want to rethink this decision in the future and throw appropriate type of error