@finos/legend-graph 10.1.2 → 11.0.0

package/src/models/protocols/pure/v1/V1_PureGraphManager.ts

@@ -17,7 +17,6 @@
 import { GRAPH_MANAGER_EVENT } from '../../../../graphManager/GraphManagerEvent.js';
 import {
   CORE_PURE_PATH,
-  ELEMENT_PATH_DELIMITER,
   PackageableElementPointerType,
 } from '../../../../MetaModelConst.js';
 import {
@@ -103,12 +102,12 @@ import {
   type V1_PackageableElementVisitor,
   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 {
   type V1_GraphBuilderContext,
@@ -164,8 +163,6 @@ import {
 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 type { V1_Multiplicity } from './model/packageableElements/domain/V1_Multiplicity.js';
-import type { V1_RawVariable } from './model/rawValueSpecification/V1_RawVariable.js';
 import { V1_setupDatabaseSerialization } from './transformation/pureProtocol/serializationHelpers/V1_DatabaseSerializationHelper.js';
 import {
   V1_setupEngineRuntimeSerialization,
@@ -254,38 +251,13 @@ import {
   V1_buildModelCoverageAnalysisResult,
   V1_MappingModelCoverageAnalysisInput,
   V1_MappingModelCoverageAnalysisResult,
-} from './engine/analytics/V1_MappingAnalytics.js';
+} from './engine/analytics/V1_MappingModelCoverageAnalysis.js';
 import type {
   MappingModelCoverageAnalysisResult,
   RawMappingModelCoverageAnalysisResult,
-} from '../../../../graphManager/action/analytics/MappingAnalytics.js';
+} from '../../../../graphManager/action/analytics/MappingModelCoverageAnalysis.js';
 import { deserialize } from 'serializr';
-
-const V1_FUNCTION_SUFFIX_MULTIPLICITY_INFINITE = 'MANY';
-
-const getMultiplicitySuffix = (multiplicity: V1_Multiplicity): string => {
-  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: V1_RawVariable): string =>
-  `${variable.class
-    .split(ELEMENT_PATH_DELIMITER)
-    .pop()}_${getMultiplicitySuffix(variable.multiplicity)}_`;
-
-const getFunctionSuffix = (fn: V1_ConcreteFunctionDefinition): string =>
-  `${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: V1_PackageableElement[] = [];
@@ -333,7 +305,7 @@ const mergePureModelContextData = (
   return mergedData;
 };
 
-const indexPureModelContextData = (
+export const V1_indexPureModelContextData = (
   report: GraphBuilderReport,
   data: V1_PureModelContextData,
   extensions: V1_GraphBuilderExtensions,
@@ -438,7 +410,7 @@ const indexPureModelContextData = (
 // NOTE: this interface is somewhat naive since `model` is of type `BasicModel`,
 // so this can only be used for pre-processing/indexing
 // we might need to change model to PureModel in the future when we support other use case
-interface V1_GraphBuilderInput {
+interface V1_PureGraphBuilderInput {
   model: BasicModel;
   data: V1_PureModelContextDataIndex;
 }
@@ -453,7 +425,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
   // Organizing these constants will help with configuring
   // target protocol version in the future
   // See https://github.com/finos/legend-studio/issues/475
-  private static readonly TARGET_PROTOCOL_VERSION = PureClientVersion.VX_X_X;
+  static readonly TARGET_PROTOCOL_VERSION = PureClientVersion.VX_X_X;
 
   engine: V1_Engine;
   graphBuilderExtensions: V1_GraphBuilderExtensions;
@@ -543,7 +515,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
       const buildInputs = [
         {
           model: systemModel,
-          data: indexPureModelContextData(
+          data: V1_indexPureModelContextData(
             report,
             systemData,
             this.graphBuilderExtensions,
@@ -584,7 +556,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     coreModel: CoreModel,
     systemModel: SystemModel,
     dependencyManager: DependencyManager,
-    dependencyEntitiesMap: Map<string, Entity[]>,
+    dependencyEntitiesIndex: Map<string, Entity[]>,
     buildState: ActionState,
     options?: GraphBuilderOptions,
   ): Promise<GraphBuilderReport> {
@@ -601,16 +573,19 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     graph.dependencyManager = dependencyManager;
 
     try {
-      dependencyManager.initialize(dependencyEntitiesMap);
+      dependencyManager.initialize(dependencyEntitiesIndex);
 
       // deserialize
       buildState.setMessage(`Partitioning and deserializing elements...`);
-      const dependencyDataMap = new Map<string, V1_PureModelContextData>();
+      const dependencyGraphDataIndex = new Map<
+        string,
+        V1_PureModelContextData
+      >();
       await Promise.all(
-        Array.from(dependencyEntitiesMap.entries()).map(
+        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,
@@ -622,11 +597,11 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
       stopWatch.record(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_ELEMENTS_DESERIALIZED);
 
       // prepare build inputs
-      const buildInputs: V1_GraphBuilderInput[] = Array.from(
-        dependencyDataMap.entries(),
+      const buildInputs: V1_PureGraphBuilderInput[] = Array.from(
+        dependencyGraphDataIndex.entries(),
       ).map(([dependencyKey, dependencyData]) => ({
         model: graph.dependencyManager.getModel(dependencyKey),
-        data: indexPureModelContextData(
+        data: V1_indexPureModelContextData(
           report,
           dependencyData,
           this.graphBuilderExtensions,
@@ -644,7 +619,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
       );
 
       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,
@@ -685,10 +660,10 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
       stopWatch.record(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_ELEMENTS_DESERIALIZED);
 
       // prepare build inputs
-      const buildInputs: V1_GraphBuilderInput[] = [
+      const buildInputs: V1_PureGraphBuilderInput[] = [
         {
           model: graph,
-          data: indexPureModelContextData(
+          data: V1_indexPureModelContextData(
             report,
             data,
             this.graphBuilderExtensions,
@@ -754,12 +729,15 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     try {
       // deserialize
       buildState.setMessage(`Deserializing elements...`);
-      const generatedDataMap = new Map<string, V1_PureModelContextData>();
+      const generationGraphDataIndex = new Map<
+        string,
+        V1_PureModelContextData
+      >();
       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,
@@ -771,11 +749,11 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
       stopWatch.record(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_ELEMENTS_DESERIALIZED);
 
       // prepare build inputs
-      const buildInputs: V1_GraphBuilderInput[] = Array.from(
-        generatedDataMap.entries(),
+      const buildInputs: V1_PureGraphBuilderInput[] = Array.from(
+        generationGraphDataIndex.entries(),
       ).map(([generationParentPath, generatedData]) => ({
         model: generatedModel,
-        data: indexPureModelContextData(
+        data: V1_indexPureModelContextData(
           report,
           generatedData,
           this.graphBuilderExtensions,
@@ -793,7 +771,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
       );
 
       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,
@@ -820,7 +798,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
 
   private async buildGraphFromInputs(
     graph: PureModel,
-    inputs: V1_GraphBuilderInput[],
+    inputs: V1_PureGraphBuilderInput[],
     report: GraphBuilderReport,
     stopWatch: StopWatch,
     graphBuilderState: ActionState,
@@ -905,7 +883,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
    */
   private async initializeAndIndexElements(
     graph: PureModel,
-    inputs: V1_GraphBuilderInput[],
+    inputs: V1_PureGraphBuilderInput[],
     options?: GraphBuilderOptions,
   ): Promise<void> {
     // create the element path cache for faster duplication check
@@ -926,7 +904,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
           input.data.nativeElements.map((element) =>
             this.visitWithGraphBuilderErrorHandling(
               element,
-              new V1_ProtocolToMetaModelGraphFirstPassBuilder(
+              new V1_ElementFirstPassBuilder(
                 this.getBuilderContext(graph, input.model, element, options),
                 packageCache,
                 elementPathCache,
@@ -941,7 +919,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
                 (element) =>
                   this.visitWithGraphBuilderErrorHandling(
                     element,
-                    new V1_ProtocolToMetaModelGraphFirstPassBuilder(
+                    new V1_ElementFirstPassBuilder(
                       this.getBuilderContext(
                         graph,
                         input.model,
@@ -961,7 +939,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
 
   private async buildTypes(
     graph: PureModel,
-    inputs: V1_GraphBuilderInput[],
+    inputs: V1_PureGraphBuilderInput[],
     options?: GraphBuilderOptions,
   ): Promise<void> {
     // Second pass
@@ -970,7 +948,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         input.data.profiles.map((element) =>
           this.visitWithGraphBuilderErrorHandling(
             element,
-            new V1_ProtocolToMetaModelGraphSecondPassBuilder(
+            new V1_ElementSecondPassBuilder(
               this.getBuilderContext(graph, input.model, element, options),
             ),
           ),
@@ -982,7 +960,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         input.data.classes.map((element) =>
           this.visitWithGraphBuilderErrorHandling(
             element,
-            new V1_ProtocolToMetaModelGraphSecondPassBuilder(
+            new V1_ElementSecondPassBuilder(
               this.getBuilderContext(graph, input.model, element, options),
             ),
           ),
@@ -994,7 +972,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         input.data.enumerations.map((element) =>
           this.visitWithGraphBuilderErrorHandling(
             element,
-            new V1_ProtocolToMetaModelGraphSecondPassBuilder(
+            new V1_ElementSecondPassBuilder(
               this.getBuilderContext(graph, input.model, element, options),
             ),
           ),
@@ -1006,7 +984,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         input.data.measures.map((element) =>
           this.visitWithGraphBuilderErrorHandling(
             element,
-            new V1_ProtocolToMetaModelGraphSecondPassBuilder(
+            new V1_ElementSecondPassBuilder(
               this.getBuilderContext(graph, input.model, element, options),
             ),
           ),
@@ -1018,7 +996,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         input.data.functions.map((element) =>
           this.visitWithGraphBuilderErrorHandling(
             element,
-            new V1_ProtocolToMetaModelGraphSecondPassBuilder(
+            new V1_ElementSecondPassBuilder(
               this.getBuilderContext(graph, input.model, element, options),
             ),
           ),
@@ -1031,7 +1009,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         input.data.classes.map((element) =>
           this.visitWithGraphBuilderErrorHandling(
             element,
-            new V1_ProtocolToMetaModelGraphThirdPassBuilder(
+            new V1_ElementThirdPassBuilder(
               this.getBuilderContext(graph, input.model, element, options),
             ),
           ),
@@ -1043,7 +1021,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         input.data.associations.map((element) =>
           this.visitWithGraphBuilderErrorHandling(
             element,
-            new V1_ProtocolToMetaModelGraphThirdPassBuilder(
+            new V1_ElementThirdPassBuilder(
               this.getBuilderContext(graph, input.model, element, options),
             ),
           ),
@@ -1056,7 +1034,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         input.data.classes.map((element) =>
           this.visitWithGraphBuilderErrorHandling(
             element,
-            new V1_ProtocolToMetaModelGraphFourthPassBuilder(
+            new V1_ElementFourthPassBuilder(
               this.getBuilderContext(graph, input.model, element, options),
             ),
           ),
@@ -1068,7 +1046,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         input.data.associations.map((element) =>
           this.visitWithGraphBuilderErrorHandling(
             element,
-            new V1_ProtocolToMetaModelGraphFourthPassBuilder(
+            new V1_ElementFourthPassBuilder(
               this.getBuilderContext(graph, input.model, element, options),
             ),
           ),
@@ -1081,7 +1059,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         input.data.classes.map((element) =>
           this.visitWithGraphBuilderErrorHandling(
             element,
-            new V1_ProtocolToMetaModelGraphFifthPassBuilder(
+            new V1_ElementFifthPassBuilder(
               this.getBuilderContext(graph, input.model, element, options),
             ),
           ),
@@ -1092,7 +1070,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
 
   private async buildStores(
     graph: PureModel,
-    inputs: V1_GraphBuilderInput[],
+    inputs: V1_PureGraphBuilderInput[],
     options?: GraphBuilderOptions,
   ): Promise<void> {
     await Promise.all(
@@ -1100,7 +1078,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         input.data.stores.map((element) =>
           this.visitWithGraphBuilderErrorHandling(
             element,
-            new V1_ProtocolToMetaModelGraphSecondPassBuilder(
+            new V1_ElementSecondPassBuilder(
               this.getBuilderContext(graph, input.model, element, options),
             ),
           ),
@@ -1112,7 +1090,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         input.data.stores.map((element) =>
           this.visitWithGraphBuilderErrorHandling(
             element,
-            new V1_ProtocolToMetaModelGraphThirdPassBuilder(
+            new V1_ElementThirdPassBuilder(
               this.getBuilderContext(graph, input.model, element, options),
             ),
           ),
@@ -1124,7 +1102,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         input.data.stores.map((element) =>
           this.visitWithGraphBuilderErrorHandling(
             element,
-            new V1_ProtocolToMetaModelGraphFourthPassBuilder(
+            new V1_ElementFourthPassBuilder(
               this.getBuilderContext(graph, input.model, element, options),
             ),
           ),
@@ -1136,7 +1114,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         input.data.stores.map((element) =>
           this.visitWithGraphBuilderErrorHandling(
             element,
-            new V1_ProtocolToMetaModelGraphFifthPassBuilder(
+            new V1_ElementFifthPassBuilder(
               this.getBuilderContext(graph, input.model, element, options),
             ),
           ),
@@ -1147,7 +1125,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
 
   private async buildMappings(
     graph: PureModel,
-    inputs: V1_GraphBuilderInput[],
+    inputs: V1_PureGraphBuilderInput[],
     options?: GraphBuilderOptions,
   ): Promise<void> {
     await Promise.all(
@@ -1155,7 +1133,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         input.data.mappings.map((element) =>
           this.visitWithGraphBuilderErrorHandling(
             element,
-            new V1_ProtocolToMetaModelGraphSecondPassBuilder(
+            new V1_ElementSecondPassBuilder(
               this.getBuilderContext(graph, input.model, element, options),
             ),
           ),
@@ -1167,7 +1145,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         input.data.mappings.map((element) =>
           this.visitWithGraphBuilderErrorHandling(
             element,
-            new V1_ProtocolToMetaModelGraphThirdPassBuilder(
+            new V1_ElementThirdPassBuilder(
               this.getBuilderContext(graph, input.model, element, options),
             ),
           ),
@@ -1179,7 +1157,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         input.data.mappings.map((element) =>
           this.visitWithGraphBuilderErrorHandling(
             element,
-            new V1_ProtocolToMetaModelGraphFourthPassBuilder(
+            new V1_ElementFourthPassBuilder(
               this.getBuilderContext(graph, input.model, element, options),
             ),
           ),
@@ -1190,7 +1168,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
 
   private async buildConnectionsAndRuntimes(
     graph: PureModel,
-    inputs: V1_GraphBuilderInput[],
+    inputs: V1_PureGraphBuilderInput[],
     options?: GraphBuilderOptions,
   ): Promise<void> {
     // NOTE: connections must be built before runtimes
@@ -1199,7 +1177,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         input.data.connections.map((element) =>
           this.visitWithGraphBuilderErrorHandling(
             element,
-            new V1_ProtocolToMetaModelGraphSecondPassBuilder(
+            new V1_ElementSecondPassBuilder(
               this.getBuilderContext(graph, input.model, element, options),
             ),
           ),
@@ -1211,7 +1189,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         input.data.runtimes.map((element) =>
           this.visitWithGraphBuilderErrorHandling(
             element,
-            new V1_ProtocolToMetaModelGraphSecondPassBuilder(
+            new V1_ElementSecondPassBuilder(
               this.getBuilderContext(graph, input.model, element, options),
             ),
           ),
@@ -1222,7 +1200,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
 
   private async buildServices(
     graph: PureModel,
-    inputs: V1_GraphBuilderInput[],
+    inputs: V1_PureGraphBuilderInput[],
     options?: GraphBuilderOptions,
   ): Promise<void> {
     await Promise.all(
@@ -1230,7 +1208,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         input.data.services.map((element) =>
           this.visitWithGraphBuilderErrorHandling(
             element,
-            new V1_ProtocolToMetaModelGraphSecondPassBuilder(
+            new V1_ElementSecondPassBuilder(
               this.getBuilderContext(graph, input.model, element, options),
             ),
           ),
@@ -1241,7 +1219,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
 
   private async buildDataElements(
     graph: PureModel,
-    inputs: V1_GraphBuilderInput[],
+    inputs: V1_PureGraphBuilderInput[],
     options?: GraphBuilderOptions,
   ): Promise<void> {
     await Promise.all(
@@ -1249,7 +1227,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         input.data.dataElements.map((element) =>
           this.visitWithGraphBuilderErrorHandling(
             element,
-            new V1_ProtocolToMetaModelGraphSecondPassBuilder(
+            new V1_ElementSecondPassBuilder(
               this.getBuilderContext(graph, input.model, element, options),
             ),
           ),
@@ -1260,7 +1238,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
 
   private async buildFileGenerations(
     graph: PureModel,
-    inputs: V1_GraphBuilderInput[],
+    inputs: V1_PureGraphBuilderInput[],
     options?: GraphBuilderOptions,
   ): Promise<void> {
     await Promise.all(
@@ -1268,7 +1246,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         input.data.fileGenerations.map((element) =>
           this.visitWithGraphBuilderErrorHandling(
             element,
-            new V1_ProtocolToMetaModelGraphSecondPassBuilder(
+            new V1_ElementSecondPassBuilder(
               this.getBuilderContext(graph, input.model, element, options),
             ),
           ),
@@ -1279,7 +1257,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
 
   private async buildGenerationSpecifications(
     graph: PureModel,
-    inputs: V1_GraphBuilderInput[],
+    inputs: V1_PureGraphBuilderInput[],
     options?: GraphBuilderOptions,
   ): Promise<void> {
     await Promise.all(
@@ -1287,7 +1265,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         input.data.generationSpecifications.map((element) =>
           this.visitWithGraphBuilderErrorHandling(
             element,
-            new V1_ProtocolToMetaModelGraphSecondPassBuilder(
+            new V1_ElementSecondPassBuilder(
               this.getBuilderContext(graph, input.model, element, options),
             ),
           ),
@@ -1298,7 +1276,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
 
   private async buildSectionIndices(
     graph: PureModel,
-    inputs: V1_GraphBuilderInput[],
+    inputs: V1_PureGraphBuilderInput[],
     options?: GraphBuilderOptions,
   ): Promise<void> {
     await Promise.all(
@@ -1306,7 +1284,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         input.data.sectionIndices.map((element) =>
           this.visitWithGraphBuilderErrorHandling(
             element,
-            new V1_ProtocolToMetaModelGraphSecondPassBuilder(
+            new V1_ElementSecondPassBuilder(
               this.getBuilderContext(graph, input.model, element, options),
             ),
           ),
@@ -1317,7 +1295,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
 
   private async buildOtherElements(
     graph: PureModel,
-    inputs: V1_GraphBuilderInput[],
+    inputs: V1_PureGraphBuilderInput[],
     options?: GraphBuilderOptions,
   ): Promise<void> {
     await Promise.all(
@@ -1329,7 +1307,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
                 (element) =>
                   this.visitWithGraphBuilderErrorHandling(
                     element,
-                    new V1_ProtocolToMetaModelGraphSecondPassBuilder(
+                    new V1_ElementSecondPassBuilder(
                       this.getBuilderContext(
                         graph,
                         input.model,
@@ -1347,7 +1325,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
                 (element) =>
                   this.visitWithGraphBuilderErrorHandling(
                     element,
-                    new V1_ProtocolToMetaModelGraphThirdPassBuilder(
+                    new V1_ElementThirdPassBuilder(
                       this.getBuilderContext(
                         graph,
                         input.model,
@@ -1365,7 +1343,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
                 (element) =>
                   this.visitWithGraphBuilderErrorHandling(
                     element,
-                    new V1_ProtocolToMetaModelGraphFourthPassBuilder(
+                    new V1_ElementFourthPassBuilder(
                       this.getBuilderContext(
                         graph,
                         input.model,
@@ -1383,7 +1361,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
                 (element) =>
                   this.visitWithGraphBuilderErrorHandling(
                     element,
-                    new V1_ProtocolToMetaModelGraphFifthPassBuilder(
+                    new V1_ElementFifthPassBuilder(
                       this.getBuilderContext(
                         graph,
                         input.model,
@@ -1462,8 +1440,15 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
   async pureCodeToLambda(
     lambda: string,
     lambdaId?: string,
+    options?: {
+      pruneSourceInformation?: boolean;
+    },
   ): Promise<RawLambda> {
-    const result = await this.engine.transformCodeToLambda(lambda, lambdaId);
+    const result = await this.engine.transformCodeToLambda(
+      lambda,
+      lambdaId,
+      options,
+    );
     return new RawLambda(result.parameters, result.body);
   }
 
@@ -1783,7 +1768,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     // deserialize json and builds metamodal raw value spec
     const rawValueSpecification = V1_deserializeRawValueSpecification(json);
     return rawValueSpecification.accept_RawValueSpecificationVisitor(
-      new V1_ProtocolToMetaModelRawValueSpecificationBuilder(
+      new V1_RawValueSpecificationBuilder(
         new V1_GraphBuilderContextBuilder(
           graph,
           graph,
@@ -1971,10 +1956,10 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
   };
 
   async executeMapping(
-    graph: PureModel,
-    mapping: Mapping,
     lambda: RawLambda,
+    mapping: Mapping,
     runtime: Runtime,
+    graph: PureModel,
     options?: ExecutionOptions,
   ): Promise<ExecutionResult> {
     return V1_buildExecutionResult(
@@ -1992,11 +1977,11 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
   }
 
   generateExecuteTestData(
-    graph: PureModel,
-    mapping: Mapping,
     lambda: RawLambda,
-    runtime: Runtime,
     parameters: (string | number | boolean)[],
+    mapping: Mapping,
+    runtime: Runtime,
+    graph: PureModel,
     options?: {
       anonymizeGeneratedData?: boolean;
     },
@@ -2019,10 +2004,10 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
   }
 
   generateExecutionPlan(
-    graph: PureModel,
-    mapping: Mapping,
     lambda: RawLambda,
+    mapping: Mapping,
     runtime: Runtime,
+    graph: PureModel,
   ): Promise<RawExecutionPlan> {
     return this.engine.generateExecutionPlan(
       this.createExecutionInput(
@@ -2036,10 +2021,10 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
   }
 
   async debugExecutionPlanGeneration(
-    graph: PureModel,
-    mapping: Mapping,
     lambda: RawLambda,
+    mapping: Mapping,
     runtime: Runtime,
+    graph: PureModel,
   ): Promise<{ plan: RawExecutionPlan; debug: string }> {
     const result = await this.engine.debugExecutionPlanGeneration(
       this.createExecutionInput(
@@ -2100,13 +2085,13 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
   // --------------------------------------------- Service ---------------------------------------------
 
   async registerService(
-    graph: PureModel,
     service: Service,
-    groupdId: string,
+    graph: PureModel,
+    groupId: string,
     artifactId: string,
+    version: string | undefined,
     server: string,
     executionMode: ServiceExecutionMode,
-    version: string | undefined,
   ): Promise<ServiceRegistrationResult> {
     const serverServiceInfo = await this.engine.getServerServiceInfo();
     // input
@@ -2123,7 +2108,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();
@@ -2160,7 +2145,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(
@@ -2227,78 +2212,6 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     );
   }
 
-  // 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: PureModel,
-    _entities: Entity[],
-    dependencyEntities: Map<string, Entity[]>,
-    entityFilterFunc?: (entity: Entity) => boolean,
-  ): Promise<V1_GraphBuilderInput[]> {
-    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<string, V1_PureModelContextData>();
-    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: V1_GraphBuilderInput[] = 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: V1_GraphBuilderInput[] = [
-      {
-        model: graph,
-        data: indexPureModelContextData(
-          report,
-          data,
-          this.graphBuilderExtensions,
-        ),
-      },
-    ];
-    const graphBuilderInput = [
-      ...dependencyGraphBuilderInput,
-      ...mainGraphBuilderInput,
-    ];
-    await this.initializeAndIndexElements(graph, graphBuilderInput);
-    return graphBuilderInput;
-  }
-
   // --------------------------------------------- Query ------------------------------------------------------
 
   async getQuery(queryId: string, graph: PureModel): Promise<Query> {
@@ -2385,18 +2298,15 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
   };
 
   async analyzeMappingModelCoverage(
-    graph: PureModel,
     mapping: Mapping,
+    graph: PureModel,
   ): Promise<MappingModelCoverageAnalysisResult> {
-    const modelCoverageAnalysisInput =
-      new V1_MappingModelCoverageAnalysisInput();
-    modelCoverageAnalysisInput.clientVersion =
-      V1_PureGraphManager.TARGET_PROTOCOL_VERSION;
-    modelCoverageAnalysisInput.mapping = mapping.path;
-    modelCoverageAnalysisInput.model =
-      this.buildMappingModelCoverageAnalysisInputContextData(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(modelCoverageAnalysisInput),
+      await this.engine.analyzeMappingModelCoverage(input),
     );
   }
 
@@ -2411,22 +2321,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     );
   }
 
-  // --------------------------------------------- Utilities ---------------------------------------------
-
-  elementToEntity = (
-    element: PackageableElement,
-    options?: {
-      pruneSourceInformation?: boolean;
-    },
-  ): Entity => {
-    const entity = this.elementProtocolToEntity(
-      this.elementToProtocol<V1_PackageableElement>(element),
-    );
-    if (options?.pruneSourceInformation) {
-      entity.content = pruneSourceInformation(entity.content);
-    }
-    return entity;
-  };
+  // --------------------------------------------- Database ---------------------------------------------
 
   async buildDatabase(input: DatabaseBuilderInput): Promise<Entity[]> {
     const dbBuilderInput = new V1_DatabaseBuilderInput();
@@ -2571,21 +2466,125 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     );
   }
 
+  // --------------------------------------------- Utilities ---------------------------------------------
+
+  elementToEntity = (
+    element: PackageableElement,
+    options?: {
+      pruneSourceInformation?: boolean;
+    },
+  ): Entity => {
+    const entity = this.elementProtocolToEntity(
+      this.elementToProtocol<V1_PackageableElement>(element),
+    );
+    if (options?.pruneSourceInformation) {
+      entity.content = pruneSourceInformation(entity.content);
+    }
+    return entity;
+  };
+
   // --------------------------------------------- Shared ---------------------------------------------
 
-  private async entitiesToPureModelContextData(
+  /**
+   * 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: PureModel,
     entities: Entity[],
-  ): Promise<V1_PureModelContextData> {
-    const graphData = new V1_PureModelContextData();
+    dependencyEntities: Map<string, Entity[]>,
+    entityFilterFn?: ((entity: Entity) => boolean) | undefined,
+    entityProcessorFn?: ((entity: Entity) => Entity) | undefined,
+  ): Promise<V1_PureGraphBuilderInput[]> {
+    const report = new GraphBuilderReport();
+
+    // build main graph builder input
+    const data = new V1_PureModelContextData();
     await V1_entitiesToPureModelContextData(
-      entities,
-      graphData,
+      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(),
     );
-    return graphData;
+    const mainGraphBuilderInput: V1_PureGraphBuilderInput[] = [
+      {
+        model: graph,
+        data: V1_indexPureModelContextData(
+          report,
+          data,
+          this.graphBuilderExtensions,
+        ),
+      },
+    ];
+
+    // build dependencies graph builder input
+    graph.dependencyManager.initialize(dependencyEntities);
+    const dependencyGraphDataIndex = new Map<string, V1_PureModelContextData>();
+    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: V1_PureGraphBuilderInput[] = 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;
   }
 
-  private getFullGraphModelData(
+  getFullGraphModelData(
     graph: PureModel,
     options?: { keepSourceInformation?: boolean | undefined } | undefined,
   ): V1_PureModelContextData {
@@ -2600,6 +2599,29 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     return contextData1;
   }
 
+  elementProtocolToEntity = (
+    elementProtocol: V1_PackageableElement,
+  ): Entity => ({
+    path: this.getElementPath(elementProtocol),
+    content: V1_serializePackageableElement(
+      elementProtocol,
+      this.pluginManager.getPureProtocolProcessorPlugins(),
+    ),
+    classifierPath: this.getElementClassiferPath(elementProtocol),
+  });
+
+  private async entitiesToPureModelContextData(
+    entities: Entity[],
+  ): Promise<V1_PureModelContextData> {
+    const graphData = new V1_PureModelContextData();
+    await V1_entitiesToPureModelContextData(
+      entities,
+      graphData,
+      this.pluginManager.getPureProtocolProcessorPlugins(),
+    );
+    return graphData;
+  }
+
   private elementToProtocol = <T extends V1_PackageableElement>(
     element: PackageableElement,
     options?: { keepSourceInformation?: boolean | undefined } | undefined,
@@ -2621,17 +2643,6 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
       this.elementProtocolToEntity(element),
     );
 
-  private elementProtocolToEntity = (
-    elementProtocol: V1_PackageableElement,
-  ): Entity => ({
-    path: this.getElementPath(elementProtocol),
-    content: V1_serializePackageableElement(
-      elementProtocol,
-      this.pluginManager.getPureProtocolProcessorPlugins(),
-    ),
-    classifierPath: this.getElementClassiferPath(elementProtocol),
-  });
-
   private getElementPath = (elementProtocol: V1_PackageableElement): string => {
     let name = elementProtocol.name;
     // These functions calculation the function suffix and are used to identify if an
@@ -2640,7 +2651,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     // TODO: to be revised when we support function overloading
     if (elementProtocol instanceof V1_ConcreteFunctionDefinition) {
       const suffixIndex = elementProtocol.name.indexOf(
-        getFunctionSuffix(elementProtocol),
+        V1_getFunctionSuffix(elementProtocol),
       );
       if (suffixIndex > 0) {
         name = elementProtocol.name.substring(0, suffixIndex - 1);