@finos/legend-graph 10.1.0 → 11.0.0

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

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 import { GRAPH_MANAGER_EVENT } from '../../../../graphManager/GraphManagerEvent.js';
-import { CORE_PURE_PATH, ELEMENT_PATH_DELIMITER, PackageableElementPointerType, } from '../../../../MetaModelConst.js';
-import { TracerService, LogEvent, getClass, guaranteeNonNullable, UnsupportedOperationError, assertTrue, assertErrorThrown, promisify, StopWatch, filterByType, isNonNullable, addUniqueEntry, uuid, deleteEntry, assertType, uniq, } from '@finos/legend-shared';
+import { CORE_PURE_PATH, PackageableElementPointerType, } from '../../../../MetaModelConst.js';
+import { TracerService, LogEvent, getClass, guaranteeNonNullable, UnsupportedOperationError, assertTrue, assertErrorThrown, promisify, StopWatch, isNonNullable, addUniqueEntry, uuid, deleteEntry, assertType, uniq, IllegalStateError, } from '@finos/legend-shared';
 import { AbstractPureGraphManager, } from '../../../../graphManager/AbstractPureGraphManager.js';
 import { PureModel, } from '../../../../graph/PureModel.js';
 import { RawLambda } from '../../../metamodels/pure/rawValueSpecification/RawLambda.js';
@@ -28,12 +28,12 @@ import { V1_serializePackageableElement } from './transformation/pureProtocol/V1
 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_ElementFirstPassBuilder } from './transformation/pureGraph/to/V1_ElementFirstPassBuilder.js';
+import { V1_ElementSecondPassBuilder } from './transformation/pureGraph/to/V1_ElementSecondPassBuilder.js';
+import { V1_ElementThirdPassBuilder } from './transformation/pureGraph/to/V1_ElementThirdPassBuilder.js';
+import { V1_ElementFourthPassBuilder } from './transformation/pureGraph/to/V1_ElementFourthPassBuilder.js';
+import { V1_ElementFifthPassBuilder } from './transformation/pureGraph/to/V1_ElementFifthPassBuilder.js';
+import { V1_RawValueSpecificationBuilder } from './transformation/pureGraph/to/V1_RawValueSpecificationBuilder.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';
@@ -72,7 +72,7 @@ import { V1_GraphTransformerContextBuilder } from './transformation/pureGraph/fr
 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_buildQuery, V1_buildServiceRegistrationResult, V1_transformQuery, V1_buildGenerationOutput, V1_buildLightQuery, V1_transformQuerySearchSpecification, } from './engine/V1_EngineHelper.js';
 import { V1_buildExecutionResult } from './engine/execution/V1_ExecutionHelper.js';
 import { ENTITY_PATH_DELIMITER, } from '@finos/legend-model-storage';
 import { DependencyGraphBuilderError, GraphBuilderError, PureClientVersion, SystemGraphBuilderError, } from '../../../../graphManager/GraphManagerUtils.js';
@@ -83,29 +83,13 @@ import { V1_DataElement } from './model/packageableElements/data/V1_DataElement.
 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 { TestFailed, } from '../../../metamodels/pure/test/result/TestResult.js';
+import { TestFailed, TestError, } from '../../../metamodels/pure/test/result/TestResult.js';
 import { getNullableIDFromTestable, getNullableTestable, } from '../../../../helpers/Testable_Helper.js';
 import { TestSuite, } from '../../../metamodels/pure/test/Test.js';
 import { pruneSourceInformation } from '../../../../MetaModelUtils.js';
-import { V1_buildModelCoverageAnalysisResult, V1_MappingModelCoverageAnalysisInput, V1_MappingModelCoverageAnalysisResult, } from './engine/analytics/V1_MappingAnalytics.js';
+import { V1_buildModelCoverageAnalysisResult, V1_MappingModelCoverageAnalysisInput, V1_MappingModelCoverageAnalysisResult, } from './engine/analytics/V1_MappingModelCoverageAnalysis.js';
 import { deserialize } from 'serializr';
-const V1_FUNCTION_SUFFIX_MULTIPLICITY_INFINITE = 'MANY';
-const getMultiplicitySuffix = (multiplicity) => {
-    if (multiplicity.lowerBound === multiplicity.upperBound) {
-        return multiplicity.lowerBound.toString();
-    }
-    else if (multiplicity.lowerBound === 0 &&
-        multiplicity.upperBound === undefined) {
-        return V1_FUNCTION_SUFFIX_MULTIPLICITY_INFINITE;
-    }
-    return `$${multiplicity.lowerBound}_${multiplicity.upperBound ?? V1_FUNCTION_SUFFIX_MULTIPLICITY_INFINITE}$`;
-};
-const getVariableSuffix = (variable) => `${variable.class
-    .split(ELEMENT_PATH_DELIMITER)
-    .pop()}_${getMultiplicitySuffix(variable.multiplicity)}_`;
-const getFunctionSuffix = (fn) => `${fn.parameters.map((p) => getVariableSuffix(p)).join('_')}_${fn.returnType
-    .split(ELEMENT_PATH_DELIMITER)
-    .pop()}_${getMultiplicitySuffix(fn.returnMultiplicity)}_`;
+import { V1_getFunctionSuffix } from './helper/V1_DomainHelper.js';
 class V1_PureModelContextDataIndex {
     elements = [];
     nativeElements = [];
@@ -135,7 +119,7 @@ const mergePureModelContextData = (...data) => {
     }
     return mergedData;
 };
-const indexPureModelContextData = (report, data, extensions) => {
+export const V1_indexPureModelContextData = (report, data, extensions) => {
     const index = new V1_PureModelContextDataIndex();
     index.elements = data.elements;
     const otherElementsByClass = new Map();
@@ -288,7 +272,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
             const buildInputs = [
                 {
                     model: systemModel,
-                    data: indexPureModelContextData(report, systemData, this.graphBuilderExtensions),
+                    data: V1_indexPureModelContextData(report, systemData, this.graphBuilderExtensions),
                 },
             ];
             // build
@@ -310,7 +294,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
             buildState.setMessage(undefined);
         }
     }
-    async buildDependencies(coreModel, systemModel, dependencyManager, dependencyEntitiesMap, buildState, options) {
+    async buildDependencies(coreModel, systemModel, dependencyManager, dependencyEntitiesIndex, buildState, options) {
         const stopWatch = new StopWatch();
         const report = new GraphBuilderReport();
         buildState.reset();
@@ -318,25 +302,25 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         const graph = new PureModel(coreModel, systemModel, this.pluginManager.getPureGraphPlugins());
         graph.dependencyManager = dependencyManager;
         try {
-            dependencyManager.initialize(dependencyEntitiesMap);
+            dependencyManager.initialize(dependencyEntitiesIndex);
             // deserialize
             buildState.setMessage(`Partitioning and deserializing elements...`);
-            const dependencyDataMap = new Map();
-            await Promise.all(Array.from(dependencyEntitiesMap.entries()).map(([dependencyKey, entities]) => {
+            const dependencyGraphDataIndex = new Map();
+            await Promise.all(Array.from(dependencyEntitiesIndex.entries()).map(([dependencyKey, entities]) => {
                 const projectModelData = new V1_PureModelContextData();
-                dependencyDataMap.set(dependencyKey, projectModelData);
+                dependencyGraphDataIndex.set(dependencyKey, projectModelData);
                 return V1_entitiesToPureModelContextData(entities, projectModelData, this.pluginManager.getPureProtocolProcessorPlugins());
             }));
             stopWatch.record(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_ELEMENTS_DESERIALIZED);
             // prepare build inputs
-            const buildInputs = Array.from(dependencyDataMap.entries()).map(([dependencyKey, dependencyData]) => ({
+            const buildInputs = Array.from(dependencyGraphDataIndex.entries()).map(([dependencyKey, dependencyData]) => ({
                 model: graph.dependencyManager.getModel(dependencyKey),
-                data: indexPureModelContextData(report, dependencyData, this.graphBuilderExtensions),
+                data: V1_indexPureModelContextData(report, dependencyData, this.graphBuilderExtensions),
             }));
             // build
             await this.buildGraphFromInputs(graph, buildInputs, report, stopWatch, buildState, options);
             buildState.pass();
-            report.otherStats.projectCount = dependencyEntitiesMap.size;
+            report.otherStats.projectCount = dependencyEntitiesIndex.size;
             report.timings = {
                 ...Object.fromEntries(stopWatch.records),
                 [GRAPH_MANAGER_EVENT.GRAPH_BUILDER_COMPLETED]: stopWatch.elapsed,
@@ -367,7 +351,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
             const buildInputs = [
                 {
                     model: graph,
-                    data: indexPureModelContextData(report, data, this.graphBuilderExtensions),
+                    data: V1_indexPureModelContextData(report, data, this.graphBuilderExtensions),
                 },
             ];
             // build
@@ -411,22 +395,22 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         try {
             // deserialize
             buildState.setMessage(`Deserializing elements...`);
-            const generatedDataMap = new Map();
+            const generationGraphDataIndex = new Map();
             await Promise.all(Array.from(generatedEntities.entries()).map(([generationParentPath, entities]) => {
                 const generatedData = new V1_PureModelContextData();
-                generatedDataMap.set(generationParentPath, generatedData);
+                generationGraphDataIndex.set(generationParentPath, generatedData);
                 return V1_entitiesToPureModelContextData(entities, generatedData, this.pluginManager.getPureProtocolProcessorPlugins());
             }));
             stopWatch.record(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_ELEMENTS_DESERIALIZED);
             // prepare build inputs
-            const buildInputs = Array.from(generatedDataMap.entries()).map(([generationParentPath, generatedData]) => ({
+            const buildInputs = Array.from(generationGraphDataIndex.entries()).map(([generationParentPath, generatedData]) => ({
                 model: generatedModel,
-                data: indexPureModelContextData(report, generatedData, this.graphBuilderExtensions),
+                data: V1_indexPureModelContextData(report, generatedData, this.graphBuilderExtensions),
             }));
             // build
             await this.buildGraphFromInputs(graph, buildInputs, report, stopWatch, buildState, options);
             buildState.pass();
-            report.otherStats.generationCount = generatedDataMap.size;
+            report.otherStats.generationCount = generationGraphDataIndex.size;
             report.timings = {
                 ...Object.fromEntries(stopWatch.records),
                 [GRAPH_MANAGER_EVENT.GRAPH_BUILDER_COMPLETED]: stopWatch.elapsed,
@@ -512,63 +496,63 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         await Promise.all(inputs.flatMap(async (input) => {
             // create the package cache
             const packageCache = new Map();
-            await Promise.all(input.data.nativeElements.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphFirstPassBuilder(this.getBuilderContext(graph, input.model, element, options), packageCache, elementPathCache))));
-            await Promise.all(this.graphBuilderExtensions.sortedExtraElementBuilders.flatMap(async (builder) => (input.data.otherElementsByBuilder.get(builder) ?? []).map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphFirstPassBuilder(this.getBuilderContext(graph, input.model, element, options), packageCache, elementPathCache)))));
+            await Promise.all(input.data.nativeElements.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementFirstPassBuilder(this.getBuilderContext(graph, input.model, element, options), packageCache, elementPathCache))));
+            await Promise.all(this.graphBuilderExtensions.sortedExtraElementBuilders.flatMap(async (builder) => (input.data.otherElementsByBuilder.get(builder) ?? []).map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementFirstPassBuilder(this.getBuilderContext(graph, input.model, element, options), packageCache, elementPathCache)))));
         }));
     }
     async buildTypes(graph, inputs, options) {
         // Second pass
-        await Promise.all(inputs.flatMap((input) => input.data.profiles.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
-        await Promise.all(inputs.flatMap((input) => input.data.classes.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
-        await Promise.all(inputs.flatMap((input) => input.data.enumerations.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
-        await Promise.all(inputs.flatMap((input) => input.data.measures.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
-        await Promise.all(inputs.flatMap((input) => input.data.functions.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        await Promise.all(inputs.flatMap((input) => input.data.profiles.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        await Promise.all(inputs.flatMap((input) => input.data.classes.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        await Promise.all(inputs.flatMap((input) => input.data.enumerations.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        await Promise.all(inputs.flatMap((input) => input.data.measures.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        await Promise.all(inputs.flatMap((input) => input.data.functions.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
         // Third pass
-        await Promise.all(inputs.flatMap((input) => input.data.classes.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphThirdPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
-        await Promise.all(inputs.flatMap((input) => input.data.associations.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphThirdPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        await Promise.all(inputs.flatMap((input) => input.data.classes.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementThirdPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        await Promise.all(inputs.flatMap((input) => input.data.associations.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementThirdPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
         // Fourth Pass
-        await Promise.all(inputs.flatMap((input) => input.data.classes.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphFourthPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
-        await Promise.all(inputs.flatMap((input) => input.data.associations.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphFourthPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        await Promise.all(inputs.flatMap((input) => input.data.classes.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementFourthPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        await Promise.all(inputs.flatMap((input) => input.data.associations.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementFourthPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
         // Fifth pass
-        await Promise.all(inputs.flatMap((input) => input.data.classes.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphFifthPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        await Promise.all(inputs.flatMap((input) => input.data.classes.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementFifthPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
     }
     async buildStores(graph, inputs, options) {
-        await Promise.all(inputs.flatMap((input) => input.data.stores.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
-        await Promise.all(inputs.flatMap((input) => input.data.stores.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphThirdPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
-        await Promise.all(inputs.flatMap((input) => input.data.stores.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphFourthPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
-        await Promise.all(inputs.flatMap((input) => input.data.stores.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphFifthPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        await Promise.all(inputs.flatMap((input) => input.data.stores.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        await Promise.all(inputs.flatMap((input) => input.data.stores.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementThirdPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        await Promise.all(inputs.flatMap((input) => input.data.stores.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementFourthPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        await Promise.all(inputs.flatMap((input) => input.data.stores.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementFifthPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
     }
     async buildMappings(graph, inputs, options) {
-        await Promise.all(inputs.flatMap((input) => input.data.mappings.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
-        await Promise.all(inputs.flatMap((input) => input.data.mappings.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphThirdPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
-        await Promise.all(inputs.flatMap((input) => input.data.mappings.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphFourthPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        await Promise.all(inputs.flatMap((input) => input.data.mappings.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        await Promise.all(inputs.flatMap((input) => input.data.mappings.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementThirdPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        await Promise.all(inputs.flatMap((input) => input.data.mappings.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementFourthPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
     }
     async buildConnectionsAndRuntimes(graph, inputs, options) {
         // NOTE: connections must be built before runtimes
-        await Promise.all(inputs.flatMap((input) => input.data.connections.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
-        await Promise.all(inputs.flatMap((input) => input.data.runtimes.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        await Promise.all(inputs.flatMap((input) => input.data.connections.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        await Promise.all(inputs.flatMap((input) => input.data.runtimes.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
     }
     async buildServices(graph, inputs, options) {
-        await Promise.all(inputs.flatMap((input) => input.data.services.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        await Promise.all(inputs.flatMap((input) => input.data.services.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
     }
     async buildDataElements(graph, inputs, options) {
-        await Promise.all(inputs.flatMap((input) => input.data.dataElements.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        await Promise.all(inputs.flatMap((input) => input.data.dataElements.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
     }
     async buildFileGenerations(graph, inputs, options) {
-        await Promise.all(inputs.flatMap((input) => input.data.fileGenerations.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        await Promise.all(inputs.flatMap((input) => input.data.fileGenerations.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
     }
     async buildGenerationSpecifications(graph, inputs, options) {
-        await Promise.all(inputs.flatMap((input) => input.data.generationSpecifications.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        await Promise.all(inputs.flatMap((input) => input.data.generationSpecifications.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
     }
     async buildSectionIndices(graph, inputs, options) {
-        await Promise.all(inputs.flatMap((input) => input.data.sectionIndices.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        await Promise.all(inputs.flatMap((input) => input.data.sectionIndices.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
     }
     async buildOtherElements(graph, inputs, options) {
         await Promise.all(this.graphBuilderExtensions.sortedExtraElementBuilders.map(async (builder) => {
-            await Promise.all(inputs.flatMap((input) => (input.data.otherElementsByBuilder.get(builder) ?? []).map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
-            await Promise.all(inputs.flatMap((input) => (input.data.otherElementsByBuilder.get(builder) ?? []).map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphThirdPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
-            await Promise.all(inputs.flatMap((input) => (input.data.otherElementsByBuilder.get(builder) ?? []).map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphFourthPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
-            await Promise.all(inputs.flatMap((input) => (input.data.otherElementsByBuilder.get(builder) ?? []).map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphFifthPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+            await Promise.all(inputs.flatMap((input) => (input.data.otherElementsByBuilder.get(builder) ?? []).map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+            await Promise.all(inputs.flatMap((input) => (input.data.otherElementsByBuilder.get(builder) ?? []).map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementThirdPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+            await Promise.all(inputs.flatMap((input) => (input.data.otherElementsByBuilder.get(builder) ?? []).map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementFourthPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+            await Promise.all(inputs.flatMap((input) => (input.data.otherElementsByBuilder.get(builder) ?? []).map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementFifthPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
         }));
     }
     visitWithGraphBuilderErrorHandling(element, visitor) {
@@ -602,8 +586,8 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
             !(el instanceof V1_SectionIndex));
         return this.pureModelContextDataToEntities(pmcd);
     }
-    async pureCodeToLambda(lambda, lambdaId) {
-        const result = await this.engine.transformCodeToLambda(lambda, lambdaId);
+    async pureCodeToLambda(lambda, lambdaId, options) {
+        const result = await this.engine.transformCodeToLambda(lambda, lambdaId, options);
         return new RawLambda(result.parameters, result.body);
     }
     async lambdaToPureCode(lambda, pretty) {
@@ -727,6 +711,9 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
             const runTestsResult = await this.engine.runTests(runTestsInput);
             const results = V1_buildTestsResult(runTestsResult, (_id) => getNullableTestable(_id, graph, this.pluginManager.getPureGraphManagerPlugins()));
             const result = results[0];
+            if (result instanceof TestError) {
+                throw new IllegalStateError(result.error);
+            }
             assertType(result, TestFailed);
             const status = result.assertStatuses.find((e) => e.assertion === baseAssertion);
             return guaranteeNonNullable(status);
@@ -751,7 +738,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         const json = this.serializeValueSpecification(valueSpecification);
         // deserialize json and builds metamodal raw value spec
         const rawValueSpecification = V1_deserializeRawValueSpecification(json);
-        return rawValueSpecification.accept_RawValueSpecificationVisitor(new V1_ProtocolToMetaModelRawValueSpecificationBuilder(new V1_GraphBuilderContextBuilder(graph, graph, this.graphBuilderExtensions, this.log).build()));
+        return rawValueSpecification.accept_RawValueSpecificationVisitor(new V1_RawValueSpecificationBuilder(new V1_GraphBuilderContextBuilder(graph, graph, this.graphBuilderExtensions, this.log).build()));
     }
     serializeRawValueSpecification(metamodel) {
         return V1_serializeRawValueSpecification(metamodel.accept_RawValueSpecificationVisitor(new V1_RawValueSpecificationTransformer(new V1_GraphTransformerContextBuilder(this.pluginManager.getPureProtocolProcessorPlugins()).build())));
@@ -841,20 +828,20 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         executeInput.context = new V1_RawBaseExecutionContext(); // TODO: potentially need to support more types
         return executeInput;
     };
-    async executeMapping(graph, mapping, lambda, runtime, options) {
+    async executeMapping(lambda, mapping, runtime, graph, options) {
         return V1_buildExecutionResult(await this.engine.executeMapping(this.createExecutionInput(graph, mapping, lambda, runtime, V1_PureGraphManager.TARGET_PROTOCOL_VERSION), options));
     }
-    generateExecuteTestData(graph, mapping, lambda, runtime, parameters, options) {
+    generateExecuteTestData(lambda, parameters, mapping, runtime, graph, options) {
         const testDataGenerationExecuteInput = new V1_TestDataGenerationExecutionInput();
         this.buildExecutionInput(graph, mapping, lambda, runtime, V1_PureGraphManager.TARGET_PROTOCOL_VERSION, testDataGenerationExecuteInput);
         testDataGenerationExecuteInput.parameters = parameters;
         testDataGenerationExecuteInput.hashStrings = Boolean(options?.anonymizeGeneratedData);
         return this.engine.generateExecuteTestData(testDataGenerationExecuteInput);
     }
-    generateExecutionPlan(graph, mapping, lambda, runtime) {
+    generateExecutionPlan(lambda, mapping, runtime, graph) {
         return this.engine.generateExecutionPlan(this.createExecutionInput(graph, mapping, lambda, runtime, V1_PureGraphManager.TARGET_PROTOCOL_VERSION));
     }
-    async debugExecutionPlanGeneration(graph, mapping, lambda, runtime) {
+    async debugExecutionPlanGeneration(lambda, mapping, runtime, graph) {
         const result = await this.engine.debugExecutionPlanGeneration(this.createExecutionInput(graph, mapping, lambda, runtime, V1_PureGraphManager.TARGET_PROTOCOL_VERSION));
         return {
             plan: result.plan,
@@ -871,16 +858,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         return V1_serializeExecutionNode(V1_transformExecutionNode(executionNode, new V1_GraphTransformerContextBuilder(this.pluginManager.getPureProtocolProcessorPlugins()).build()));
     }
     // --------------------------------------------- Service ---------------------------------------------
-    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.runLegacyServiceTests(protocolGraph)).map(V1_buildLegacyServiceTestResult);
-    }
-    async registerService(graph, service, groupdId, artifactId, server, executionMode, version) {
+    async registerService(service, graph, groupId, artifactId, version, server, executionMode) {
         const serverServiceInfo = await this.engine.getServerServiceInfo();
         // input
         let input;
@@ -893,7 +871,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
                 break;
             }
             case ServiceExecutionMode.SEMI_INTERACTIVE: {
-                const sdlcInfo = new V1_AlloySDLC(groupdId, artifactId, version);
+                const sdlcInfo = new V1_AlloySDLC(groupId, artifactId, version);
                 const pointer = new V1_PureModelContextPointer(protocol, sdlcInfo);
                 // data
                 const data = new V1_PureModelContextData();
@@ -920,7 +898,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
                 break;
             }
             case ServiceExecutionMode.PROD: {
-                const sdlcInfo = new V1_AlloySDLC(groupdId, artifactId, version);
+                const sdlcInfo = new V1_AlloySDLC(groupId, artifactId, version);
                 const pointer = new V1_PureModelContextPointer(protocol, sdlcInfo);
                 sdlcInfo.packageableElementPointers = [
                     new V1_PackageableElementPointer(PackageableElementPointerType.SERVICE, service.path),
@@ -952,46 +930,6 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     async getLightQuery(queryId) {
         return V1_buildLightQuery(await this.engine.getQuery(queryId), this.engine.getCurrentUserId());
     }
-    // TODO: we could potentially reshape this method to build light graph with just indexing
-    // and return a slightly more complicated object instead: separating the graph and the dependencies part instead of
-    // return a list of `V1_GraphBuilderInput`. This method would be useful for any other light graph builder algo.
-    async indexEntitiesWithDependencyIntoGraph(graph, _entities, dependencyEntities, entityFilterFunc) {
-        let entities = _entities;
-        graph.dependencyManager.initialize(dependencyEntities);
-        if (entityFilterFunc) {
-            Array.from(dependencyEntities.entries()).forEach(([dependencyKey, dEntities]) => {
-                dependencyEntities.set(dependencyKey, dEntities.filter(entityFilterFunc));
-            });
-            entities = _entities.filter(entityFilterFunc);
-        }
-        const report = new GraphBuilderReport();
-        // build dependency pmcd models
-        const dependencyDataMap = new Map();
-        await Promise.all(Array.from(dependencyEntities.entries()).map(([dependencyKey, value]) => {
-            const projectModelData = new V1_PureModelContextData();
-            dependencyDataMap.set(dependencyKey, projectModelData);
-            return V1_entitiesToPureModelContextData(value, projectModelData, this.pluginManager.getPureProtocolProcessorPlugins());
-        }));
-        const dependencyGraphBuilderInput = Array.from(dependencyDataMap.entries()).map(([dependencyKey, dependencyData]) => ({
-            data: indexPureModelContextData(report, dependencyData, this.graphBuilderExtensions),
-            model: graph.dependencyManager.getModel(dependencyKey),
-        }));
-        // build main pmcd
-        const data = new V1_PureModelContextData();
-        await V1_entitiesToPureModelContextData(entities, data, this.pluginManager.getPureProtocolProcessorPlugins());
-        const mainGraphBuilderInput = [
-            {
-                model: graph,
-                data: indexPureModelContextData(report, data, this.graphBuilderExtensions),
-            },
-        ];
-        const graphBuilderInput = [
-            ...dependencyGraphBuilderInput,
-            ...mainGraphBuilderInput,
-        ];
-        await this.initializeAndIndexElements(graph, graphBuilderInput);
-        return graphBuilderInput;
-    }
     // --------------------------------------------- Query ------------------------------------------------------
     async getQuery(queryId, graph) {
         return V1_buildQuery(await this.engine.getQuery(queryId), graph, this.engine.getCurrentUserId());
@@ -1037,26 +975,17 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
             .concat(extraElements));
         return prunedGraphData;
     };
-    async analyzeMappingModelCoverage(graph, mapping) {
-        const modelCoverageAnalysisInput = new V1_MappingModelCoverageAnalysisInput();
-        modelCoverageAnalysisInput.clientVersion =
-            V1_PureGraphManager.TARGET_PROTOCOL_VERSION;
-        modelCoverageAnalysisInput.mapping = mapping.path;
-        modelCoverageAnalysisInput.model =
-            this.buildMappingModelCoverageAnalysisInputContextData(graph);
-        return V1_buildModelCoverageAnalysisResult(await this.engine.analyzeMappingModelCoverage(modelCoverageAnalysisInput));
+    async analyzeMappingModelCoverage(mapping, graph) {
+        const input = new V1_MappingModelCoverageAnalysisInput();
+        input.clientVersion = V1_PureGraphManager.TARGET_PROTOCOL_VERSION;
+        input.mapping = mapping.path;
+        input.model = this.buildMappingModelCoverageAnalysisInputContextData(graph);
+        return V1_buildModelCoverageAnalysisResult(await this.engine.analyzeMappingModelCoverage(input));
     }
     buildMappingModelCoverageAnalysisResult(input) {
         return V1_buildModelCoverageAnalysisResult(deserialize(V1_MappingModelCoverageAnalysisResult, input));
     }
-    // --------------------------------------------- Utilities ---------------------------------------------
-    elementToEntity = (element, options) => {
-        const entity = this.elementProtocolToEntity(this.elementToProtocol(element));
-        if (options?.pruneSourceInformation) {
-            entity.content = pruneSourceInformation(entity.content);
-        }
-        return entity;
-    };
+    // --------------------------------------------- Database ---------------------------------------------
     async buildDatabase(input) {
         const dbBuilderInput = new V1_DatabaseBuilderInput();
         dbBuilderInput.connection = V1_transformRelationalDatabaseConnection(input.connection, new V1_GraphTransformerContextBuilder(this.pluginManager.getPureProtocolProcessorPlugins()).build());
@@ -1168,11 +1097,78 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
             },
         ]);
     }
+    // --------------------------------------------- Utilities ---------------------------------------------
+    elementToEntity = (element, options) => {
+        const entity = this.elementProtocolToEntity(this.elementToProtocol(element));
+        if (options?.pruneSourceInformation) {
+            entity.content = pruneSourceInformation(entity.content);
+        }
+        return entity;
+    };
     // --------------------------------------------- Shared ---------------------------------------------
-    async entitiesToPureModelContextData(entities) {
-        const graphData = new V1_PureModelContextData();
-        await V1_entitiesToPureModelContextData(entities, graphData, this.pluginManager.getPureProtocolProcessorPlugins());
-        return graphData;
+    /**
+     * This method helps indexing the graph from graph and dependencies' entities
+     * This will produce a _light_ graph with empty unprocesed elements, they are just indexed in the graph
+     * and the Pure model context data which can be used to further build the graph
+     *
+     * There are a few simple analytics we want to do on the graph which does not necessarily
+     * require us to build the full-graph, in fact, doing so would be too costly. In those scenarios,
+     * we need to build the _light_ graph, hence the existence of this utility method
+     *
+     * TODO?: do we need to account for system elements?
+     */
+    async indexLightGraph(graph, entities, dependencyEntities, entityFilterFn, entityProcessorFn) {
+        const report = new GraphBuilderReport();
+        // build main graph builder input
+        const data = new V1_PureModelContextData();
+        await V1_entitiesToPureModelContextData(entities
+            .filter((entity) => {
+            // never exclude section index as it could be used for path resolution when building the graph later
+            if (entity.classifierPath === CORE_PURE_PATH.SECTION_INDEX) {
+                return true;
+            }
+            if (entityFilterFn) {
+                return entityFilterFn(entity);
+            }
+            return true;
+        })
+            .map((entity) => entityProcessorFn ? entityProcessorFn(entity) : entity), data, this.pluginManager.getPureProtocolProcessorPlugins());
+        const mainGraphBuilderInput = [
+            {
+                model: graph,
+                data: V1_indexPureModelContextData(report, data, this.graphBuilderExtensions),
+            },
+        ];
+        // build dependencies graph builder input
+        graph.dependencyManager.initialize(dependencyEntities);
+        const dependencyGraphDataIndex = new Map();
+        await Promise.all(Array.from(dependencyEntities.entries()).map(([dependencyKey, value]) => {
+            const projectModelData = new V1_PureModelContextData();
+            dependencyGraphDataIndex.set(dependencyKey, projectModelData);
+            return V1_entitiesToPureModelContextData(value
+                .filter((entity) => {
+                // never exclude section index as it could be used for path resolution when building the graph later
+                if (entity.classifierPath === CORE_PURE_PATH.SECTION_INDEX) {
+                    return true;
+                }
+                if (entityFilterFn) {
+                    return entityFilterFn(entity);
+                }
+                return true;
+            })
+                .map((entity) => entityProcessorFn ? entityProcessorFn(entity) : entity), projectModelData, this.pluginManager.getPureProtocolProcessorPlugins());
+        }));
+        const dependencyGraphBuilderInput = Array.from(dependencyGraphDataIndex.entries()).map(([dependencyKey, dependencyData]) => ({
+            data: V1_indexPureModelContextData(report, dependencyData, this.graphBuilderExtensions),
+            model: graph.dependencyManager.getModel(dependencyKey),
+        }));
+        // index simplified graph
+        const graphBuilderInput = [
+            ...dependencyGraphBuilderInput,
+            ...mainGraphBuilderInput,
+        ];
+        await this.initializeAndIndexElements(graph, graphBuilderInput);
+        return graphBuilderInput;
     }
     getFullGraphModelData(graph, options) {
         const contextData1 = this.graphToPureModelContextData(graph, {
@@ -1185,15 +1181,20 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         ];
         return contextData1;
     }
-    elementToProtocol = (element, options) => V1_transformPackageableElement(element, this.pluginManager.getPureProtocolProcessorPlugins(), new V1_GraphTransformerContextBuilder(this.pluginManager.getPureProtocolProcessorPlugins())
-        .withKeepSourceInformationFlag(Boolean(options?.keepSourceInformation))
-        .build());
-    pureModelContextDataToEntities = (graphProtocol) => graphProtocol.elements.map((element) => this.elementProtocolToEntity(element));
     elementProtocolToEntity = (elementProtocol) => ({
         path: this.getElementPath(elementProtocol),
         content: V1_serializePackageableElement(elementProtocol, this.pluginManager.getPureProtocolProcessorPlugins()),
         classifierPath: this.getElementClassiferPath(elementProtocol),
     });
+    async entitiesToPureModelContextData(entities) {
+        const graphData = new V1_PureModelContextData();
+        await V1_entitiesToPureModelContextData(entities, graphData, this.pluginManager.getPureProtocolProcessorPlugins());
+        return graphData;
+    }
+    elementToProtocol = (element, options) => V1_transformPackageableElement(element, this.pluginManager.getPureProtocolProcessorPlugins(), new V1_GraphTransformerContextBuilder(this.pluginManager.getPureProtocolProcessorPlugins())
+        .withKeepSourceInformationFlag(Boolean(options?.keepSourceInformation))
+        .build());
+    pureModelContextDataToEntities = (graphProtocol) => graphProtocol.elements.map((element) => this.elementProtocolToEntity(element));
     getElementPath = (elementProtocol) => {
         let name = elementProtocol.name;
         // These functions calculation the function suffix and are used to identify if an
@@ -1201,7 +1202,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         // if so, we will remove that suffix
         // TODO: to be revised when we support function overloading
         if (elementProtocol instanceof V1_ConcreteFunctionDefinition) {
-            const suffixIndex = elementProtocol.name.indexOf(getFunctionSuffix(elementProtocol));
+            const suffixIndex = elementProtocol.name.indexOf(V1_getFunctionSuffix(elementProtocol));
             if (suffixIndex > 0) {
                 name = elementProtocol.name.substring(0, suffixIndex - 1);
             }