@finos/legend-graph 1.3.0 → 2.0.2

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

@@ -15,7 +15,7 @@
  */
 
 import { flow, flowResult, makeObservable, runInAction } from 'mobx';
-import { GRAPH_MANAGER_LOG_EVENT } from '../../../../graphManager/GraphManagerLogEvent';
+import { GRAPH_MANAGER_EVENT } from '../../../../graphManager/GraphManagerEvent';
 import {
   CORE_PURE_PATH,
   ELEMENT_PATH_DELIMITER,
@@ -37,6 +37,9 @@ import {
   assertTrue,
   assertErrorThrown,
   promisify,
+  type ActionState,
+  StopWatch,
+  assertNonEmptyString,
 } from '@finos/legend-shared';
 import type { TEMPORARY__AbstractEngineConfig } from '../../../../graphManager/action/TEMPORARY__AbstractEngineConfig';
 import {
@@ -45,8 +48,11 @@ import {
   type GraphBuilderOptions,
   type ExecutionOptions,
 } from '../../../../graphManager/AbstractPureGraphManager';
-import type { Mapping } from '../../../metamodels/pure/packageableElements/mapping/Mapping';
-import type { Runtime } from '../../../metamodels/pure/packageableElements/runtime/Runtime';
+import { Mapping } from '../../../metamodels/pure/packageableElements/mapping/Mapping';
+import {
+  type Runtime,
+  EngineRuntime,
+} from '../../../metamodels/pure/packageableElements/runtime/Runtime';
 import type {
   ImportConfigurationDescription,
   ImportMode,
@@ -74,7 +80,11 @@ import type { ExecutionResult } from '../../../../graphManager/action/execution/
 import type { GenerationOutput } from '../../../../graphManager/action/generation/GenerationOutput';
 import type { ValueSpecification } from '../../../metamodels/pure/valueSpecification/ValueSpecification';
 import { ServiceExecutionMode } from '../../../../graphManager/action/service/ServiceExecutionMode';
-import { PureSingleExecution } from '../../../metamodels/pure/packageableElements/service/ServiceExecution';
+import {
+  KeyedExecutionParameter,
+  PureMultiExecution,
+  PureSingleExecution,
+} from '../../../metamodels/pure/packageableElements/service/ServiceExecution';
 import {
   V1_deserializeRawValueSpecification,
   V1_serializeRawValueSpecification,
@@ -160,6 +170,7 @@ import type { V1_Multiplicity } from './model/packageableElements/domain/V1_Mult
 import type { V1_RawVariable } from './model/rawValueSpecification/V1_RawVariable';
 import { V1_setupDatabaseSerialization } from './transformation/pureProtocol/serializationHelpers/V1_DatabaseSerializationHelper';
 import {
+  V1_PACKAGEABLE_RUNTIME_ELEMENT_PROTOCOL_TYPE,
   V1_setupEngineRuntimeSerialization,
   V1_setupLegacyRuntimeSerialization,
 } from './transformation/pureProtocol/serializationHelpers/V1_RuntimeSerializationHelper';
@@ -206,12 +217,23 @@ import {
   GraphBuilderError,
   SystemGraphBuilderError,
 } from '../../../../graphManager/GraphManagerUtils';
-import { PackageableElementReference } from '../../../metamodels/pure/packageableElements/PackageableElementReference';
+import {
+  PackageableElementExplicitReference,
+  PackageableElementReference,
+} from '../../../metamodels/pure/packageableElements/PackageableElementReference';
 import type { GraphPluginManager } from '../../../../GraphPluginManager';
 import type { QuerySearchSpecification } from '../../../../graphManager/action/query/QuerySearchSpecification';
 import type { ExternalFormatDescription } from '../../../../graphManager/action/externalFormat/ExternalFormatDescription';
 import type { ConfigurationProperty } from '../../../metamodels/pure/packageableElements/fileGeneration/ConfigurationProperty';
 import { V1_ExternalFormatModelGenerationInput } from './engine/externalFormat/V1_ExternalFormatModelGeneration';
+import { GraphBuilderReport } from '../../../../graphManager/GraphBuilderReport';
+import {
+  V1_PureMultiExecution,
+  V1_PureSingleExecution,
+} from './model/packageableElements/service/V1_ServiceExecution';
+import { V1_MAPPING_ELEMENT_PROTOCOL_TYPE } from './transformation/pureProtocol/serializationHelpers/V1_MappingSerializationHelper';
+import { V1_SERVICE_ELEMENT_PROTOCOL_TYPE } from './transformation/pureProtocol/serializationHelpers/V1_ServiceSerializationHelper';
+import { MappingInclude } from '../../../metamodels/pure/packageableElements/mapping/MappingInclude';
 
 const V1_FUNCTION_SUFFIX_MULTIPLICITY_INFINITE = 'MANY';
 
@@ -271,7 +293,20 @@ class V1_PureModelContextDataIndex {
   >();
 }
 
+const mergePureModelContextData = (
+  ...data: V1_PureModelContextData[]
+): V1_PureModelContextData => {
+  const mergedData = new V1_PureModelContextData();
+  for (const _data of data) {
+    mergedData.elements = mergedData.elements.concat(_data.elements);
+    mergedData.serializer = _data.serializer ?? mergedData.serializer;
+    mergedData.origin = _data.origin ?? mergedData.origin;
+  }
+  return mergedData;
+};
+
 const indexPureModelContextData = (
+  report: GraphBuilderReport,
   data: V1_PureModelContextData,
   extensions: V1_GraphBuilderExtensions,
 ): V1_PureModelContextDataIndex => {
@@ -331,6 +366,42 @@ const indexPureModelContextData = (
       (index.otherElementsByBuilder.get(builder) ?? []).concat(elements),
     );
   });
+
+  // report
+  report.elementCount.total = report.elementCount.total + index.elements.length;
+  report.elementCount.other =
+    (report.elementCount.other ?? 0) +
+    otherElementsByClass.size +
+    index.fileGenerations.length +
+    index.generationSpecifications.length;
+  report.elementCount.sectionIndex =
+    (report.elementCount.sectionIndex ?? 0) + index.sectionIndices.length;
+
+  report.elementCount.association =
+    (report.elementCount.association ?? 0) + index.associations.length;
+  report.elementCount.class =
+    (report.elementCount.class ?? 0) + index.classes.length;
+  report.elementCount.enumeration =
+    (report.elementCount.enumeration ?? 0) + index.enumerations.length;
+  report.elementCount.function =
+    (report.elementCount.function ?? 0) + index.functions.length;
+  report.elementCount.profile =
+    (report.elementCount.profile ?? 0) + index.profiles.length;
+  report.elementCount.measure =
+    (report.elementCount.measure ?? 0) + index.measures.length;
+
+  report.elementCount.store =
+    (report.elementCount.store ?? 0) + index.stores.length;
+  report.elementCount.mapping =
+    (report.elementCount.mapping ?? 0) + index.mappings.length;
+  report.elementCount.connection =
+    (report.elementCount.connection ?? 0) + index.connections.length;
+  report.elementCount.runtime =
+    (report.elementCount.runtime ?? 0) + index.runtimes.length;
+
+  report.elementCount.service =
+    (report.elementCount.service ?? 0) + index.services.length;
+
   return index;
 };
 
@@ -358,22 +429,24 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
 
     makeObservable<
       V1_PureGraphManager,
+      | 'buildGraphFromInputs'
       | 'initializeAndIndexElements'
       | 'postProcess'
       | 'buildTypes'
       | 'buildStores'
       | 'buildMappings'
       | 'buildConnectionsAndRuntimes'
-      | 'buildSectionIndex'
+      | 'buildSectionIndices'
       | 'buildOtherElements'
       | 'buildServices'
       | 'buildFileGenerations'
-      | 'buildGenerationSpecificationss'
+      | 'buildGenerationSpecifications'
     >(this, {
       initialize: flow,
       buildSystem: flow,
       buildDependencies: flow,
       buildGraph: flow,
+      buildGraphFromInputs: flow,
       buildGenerations: flow,
       initializeAndIndexElements: flow,
       postProcess: flow,
@@ -381,11 +454,11 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
       buildStores: flow,
       buildMappings: flow,
       buildConnectionsAndRuntimes: flow,
-      buildSectionIndex: flow,
+      buildSectionIndices: flow,
       buildOtherElements: flow,
       buildServices: flow,
       buildFileGenerations: flow,
-      buildGenerationSpecificationss: flow,
+      buildGenerationSpecifications: flow,
     });
 
     // setup plugins
@@ -433,8 +506,11 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     coreModel: CoreModel,
     systemModel: SystemModel,
     options?: GraphBuilderOptions,
-  ): GeneratorFn<void> {
-    const startTime = Date.now();
+  ): GeneratorFn<GraphBuilderReport> {
+    const stopWatch = new StopWatch();
+    const report = new GraphBuilderReport();
+    const graphBuilderState = systemModel.buildState;
+    graphBuilderState.reset();
 
     // Create a dummy graph for system processing. This is to ensure system model does not depend on the main graph
     const graph = new PureModel(
@@ -442,63 +518,56 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
       systemModel,
       this.pluginManager.getPureGraphPlugins(),
     );
+
     try {
-      const systemData = new V1_PureModelContextData();
-      yield V1_entitiesToPureModelContextData(
-        /**
-         * Get all system entities.
-         *
-         * NOTE: right now, we are doing extra work here: JSON -> protocol -> entities -> protocol, since we are
-         * expecting to get these models from some a remote SDLC project in the future.
-         */
-        V1_deserializePureModelContextData(V1_CORE_SYSTEM_MODELS)
-          .elements.concat(
-            this.pluginManager
-              .getPureProtocolProcessorPlugins()
-              .flatMap((plugin) => plugin.V1_getExtraSystemModels?.() ?? [])
-              .flatMap(
-                (modelContextData) =>
-                  V1_deserializePureModelContextData(modelContextData).elements,
-              ),
-          )
-          .map((element) => this.elementProtocolToEntity(element)),
-        systemData,
-        this.pluginManager.getPureProtocolProcessorPlugins(),
+      // deserialize
+      graphBuilderState.setMessage(`Collecting and deserializing elements...`);
+      const systemData = mergePureModelContextData(
+        V1_deserializePureModelContextData(V1_CORE_SYSTEM_MODELS),
+        ...this.pluginManager
+          .getPureProtocolProcessorPlugins()
+          .flatMap((plugin) => plugin.V1_getExtraSystemModels?.() ?? [])
+          .map((modelContextData) =>
+            V1_deserializePureModelContextData(modelContextData),
+          ),
       );
-      const systemGraphBuilderInput = [
+      stopWatch.record(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_ELEMENTS_DESERIALIZED);
+
+      // prepare build inputs
+      const buildInputs = [
         {
           model: systemModel,
-          data: indexPureModelContextData(systemData, this.extensions),
+          data: indexPureModelContextData(report, systemData, this.extensions),
         },
       ];
+
+      // build
       yield flowResult(
-        this.initializeAndIndexElements(graph, systemGraphBuilderInput),
+        this.buildGraphFromInputs(
+          graph,
+          buildInputs,
+          report,
+          stopWatch,
+          graphBuilderState,
+          options,
+        ),
       );
-      // NOTE: right now we only have profile and enumeration for system, we might need to generalize this step in the future
-      yield flowResult(this.buildTypes(graph, systemGraphBuilderInput));
-      yield flowResult(this.buildOtherElements(graph, systemGraphBuilderInput));
-      yield flowResult(this.postProcess(graph, systemGraphBuilderInput));
-      if (!options?.quiet) {
-        this.log.info(
-          LogEvent.create(GRAPH_MANAGER_LOG_EVENT.GRAPH_BUILDER_SYSTEM_BUILT),
-          Date.now() - startTime,
-          'ms',
-          `[class: ${systemModel.ownClasses.length}, profile: ${systemModel.ownProfiles.length}, enumeration: ${systemModel.ownEnumerations.length}]`,
-        );
-      }
-      systemModel.buildState.pass();
+
+      graphBuilderState.pass();
+      report.timings = {
+        ...Object.fromEntries(stopWatch.records),
+        [GRAPH_MANAGER_EVENT.GRAPH_BUILDER_COMPLETED]: stopWatch.elapsed,
+      };
+      return report;
     } catch (error) {
       assertErrorThrown(error);
-      systemModel.buildState.fail();
-      if (!options?.quiet) {
-        this.log.info(
-          LogEvent.create(GRAPH_MANAGER_LOG_EVENT.GRAPH_BUILDER_FAILURE),
-          '[ERROR]',
-          Date.now() - startTime,
-          'ms',
-        );
-      }
+      graphBuilderState.fail();
+      this.log.error(
+        LogEvent.create(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_FAILURE),
+      );
       throw new SystemGraphBuilderError(error);
+    } finally {
+      graphBuilderState.setMessage(undefined);
     }
   }
 
@@ -508,21 +577,12 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     dependencyManager: DependencyManager,
     dependencyEntitiesMap: Map<string, Entity[]>,
     options?: GraphBuilderOptions,
-  ): GeneratorFn<void> {
-    const startTime = Date.now();
-    if (!options?.quiet) {
-      this.log.info(
-        LogEvent.create(
-          GRAPH_MANAGER_LOG_EVENT.GRAPH_BUILDER_DEPENDENCIES_ENTITIES_FETCHED,
-        ),
-        Date.now() - startTime,
-        'ms',
-        `[projects: ${dependencyEntitiesMap.size}, entities: ${
-          Array.from(dependencyEntitiesMap.values()).flat().length
-        }]`,
-      );
-    }
-    dependencyManager.buildState.reset();
+  ): GeneratorFn<GraphBuilderReport> {
+    const stopWatch = new StopWatch();
+    const report = new GraphBuilderReport();
+    const graphBuilderState = dependencyManager.buildState;
+    graphBuilderState.reset();
+
     // Create a dummy graph for system processing. This is to ensure dependency models do not depend on the main graph
     const graph = new PureModel(
       coreModel,
@@ -530,9 +590,14 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
       this.pluginManager.getPureGraphPlugins(),
     );
     graph.setDependencyManager(dependencyManager);
+
     try {
       dependencyManager.initialize(dependencyEntitiesMap);
-      // Parse/Build Data
+
+      // deserialize
+      graphBuilderState.setMessage(
+        `Partitioning and deserializing elements...`,
+      );
       const dependencyDataMap = new Map<string, V1_PureModelContextData>();
       yield Promise.all(
         Array.from(dependencyEntitiesMap.entries()).map(
@@ -547,84 +612,48 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
           },
         ),
       );
-      const preprocessingFinishedTime = Date.now();
-      if (!options?.quiet) {
-        this.log.info(
-          LogEvent.create(
-            GRAPH_MANAGER_LOG_EVENT.GRAPH_BUILDER_DEPENDENCIES_PREPROCESSED,
-          ),
-          preprocessingFinishedTime - startTime,
-          'ms',
-        );
-      }
+      stopWatch.record(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_ELEMENTS_DESERIALIZED);
 
-      const graphBuilderInput: V1_GraphBuilderInput[] = Array.from(
+      // prepare build inputs
+      const buildInputs: V1_GraphBuilderInput[] = Array.from(
         dependencyDataMap.entries(),
       ).map(([dependencyKey, dependencyData]) => ({
-        data: indexPureModelContextData(dependencyData, this.extensions),
+        data: indexPureModelContextData(
+          report,
+          dependencyData,
+          this.extensions,
+        ),
         model: graph.dependencyManager.getModel(dependencyKey),
       }));
+
+      // build
       yield flowResult(
-        this.initializeAndIndexElements(graph, graphBuilderInput, options),
-      );
-      // NOTE: we might need to process sectionIndex if we support unresolved element paths in dependencies
-      yield flowResult(this.buildTypes(graph, graphBuilderInput, options));
-      yield flowResult(this.buildStores(graph, graphBuilderInput, options));
-      yield flowResult(this.buildMappings(graph, graphBuilderInput, options));
-      yield flowResult(
-        this.buildConnectionsAndRuntimes(graph, graphBuilderInput, options),
-      );
-      yield flowResult(this.buildServices(graph, graphBuilderInput, options));
-      yield flowResult(
-        this.buildFileGenerations(graph, graphBuilderInput, options),
-      );
-      yield flowResult(
-        this.buildGenerationSpecificationss(graph, graphBuilderInput, options),
-      );
-      yield flowResult(
-        this.buildOtherElements(graph, graphBuilderInput, options),
+        this.buildGraphFromInputs(
+          graph,
+          buildInputs,
+          report,
+          stopWatch,
+          graphBuilderState,
+          options,
+        ),
       );
 
-      yield flowResult(this.postProcess(graph, graphBuilderInput));
-      const processingFinishedTime = Date.now();
-      if (!options?.quiet) {
-        this.log.info(
-          LogEvent.create(
-            GRAPH_MANAGER_LOG_EVENT.GRAPH_BUILDER_DEPENDENCIES_PROCESSED,
-          ),
-          processingFinishedTime - preprocessingFinishedTime,
-          'ms',
-        );
-      }
-
-      dependencyManager.buildState.pass();
-      if (!options?.quiet) {
-        this.log.info(
-          LogEvent.create(
-            GRAPH_MANAGER_LOG_EVENT.GRAPH_BUILDER_DEPENDENCIES_BUILT,
-          ),
-          '[TOTAL]',
-          Date.now() - startTime,
-          'ms',
-        );
-      }
+      graphBuilderState.pass();
+      report.otherStats.projectCount = dependencyEntitiesMap.size;
+      report.timings = {
+        ...Object.fromEntries(stopWatch.records),
+        [GRAPH_MANAGER_EVENT.GRAPH_BUILDER_COMPLETED]: stopWatch.elapsed,
+      };
+      return report;
     } catch (error) {
       assertErrorThrown(error);
-      if (!options?.quiet) {
-        this.log.info(
-          LogEvent.create(GRAPH_MANAGER_LOG_EVENT.GRAPH_BUILDER_FAILURE),
-          '[ERROR]',
-          Date.now() - startTime,
-          'ms',
-          `[elements: ${
-            Array.from(dependencyManager.projectDependencyModelsIndex.values())
-              .map((v) => v.allOwnElements)
-              .flat().length
-          }]`,
-        );
-      }
-      dependencyManager.buildState.fail();
+      this.log.error(
+        LogEvent.create(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_FAILURE),
+      );
+      graphBuilderState.fail();
       throw new DependencyGraphBuilderError(error);
+    } finally {
+      graphBuilderState.setMessage(undefined);
     }
   }
 
@@ -632,221 +661,55 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     graph: PureModel,
     entities: Entity[],
     options?: GraphBuilderOptions,
-  ): GeneratorFn<void> {
-    let stepStartTime = Date.now();
-    let stepFinishedTime;
-    const startTime = stepStartTime;
+  ): GeneratorFn<GraphBuilderReport> {
+    const stopWatch = new StopWatch();
+    const report = new GraphBuilderReport();
+    const graphBuilderState = graph.buildState;
+    graphBuilderState.reset();
+
     try {
-      // Parse/Build Data
+      // deserialize
+      graphBuilderState.setMessage(`Deserializing elements...`);
       const data = new V1_PureModelContextData();
       yield V1_entitiesToPureModelContextData(
         entities,
         data,
         this.pluginManager.getPureProtocolProcessorPlugins(),
       );
+      stopWatch.record(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_ELEMENTS_DESERIALIZED);
 
-      const graphBuilderInput: V1_GraphBuilderInput[] = [
+      // prepare build inputs
+      const buildInputs: V1_GraphBuilderInput[] = [
         {
           model: graph,
-          data: indexPureModelContextData(data, this.extensions),
+          data: indexPureModelContextData(report, data, this.extensions),
         },
       ];
-      stepFinishedTime = Date.now();
-      if (!options?.quiet) {
-        this.log.info(
-          LogEvent.create(
-            GRAPH_MANAGER_LOG_EVENT.GRAPH_BUILDER_DATA_MODEL_PARSED,
-          ),
-          stepFinishedTime - stepStartTime,
-          'ms',
-        );
-      }
-      stepStartTime = stepFinishedTime;
-
-      yield flowResult(
-        this.initializeAndIndexElements(graph, graphBuilderInput, options),
-      );
-      stepFinishedTime = Date.now();
-      if (!options?.quiet) {
-        this.log.info(
-          LogEvent.create(
-            GRAPH_MANAGER_LOG_EVENT.GRAPH_BUILDER_ELEMENTS_INITIALIZED_AND_INDEXED,
-          ),
-          stepFinishedTime - stepStartTime,
-          'ms',
-          `[element: ${data.elements.length}]`,
-        );
-      }
-      stepStartTime = stepFinishedTime;
-
-      // Section index
-      yield flowResult(
-        this.buildSectionIndex(graph, graphBuilderInput, options),
-      );
-      stepFinishedTime = Date.now();
-      if (!options?.quiet) {
-        this.log.info(
-          LogEvent.create(
-            GRAPH_MANAGER_LOG_EVENT.GRAPH_BUILDER_SECTION_INDICES_BUILT,
-          ),
-          stepFinishedTime - stepStartTime,
-          'ms',
-          `[sectionIndex: ${graph.ownSectionIndices.length}]`,
-        );
-      }
-      stepStartTime = stepFinishedTime;
-      // Types
-      yield flowResult(this.buildTypes(graph, graphBuilderInput, options));
-      stepFinishedTime = Date.now();
-      if (!options?.quiet) {
-        this.log.info(
-          LogEvent.create(
-            GRAPH_MANAGER_LOG_EVENT.GRAPH_BUILDER_DOMAIN_MODELS_BUILT,
-          ),
-          stepFinishedTime - stepStartTime,
-          'ms',
-          `[class: ${graph.ownClasses.length}, enumeration: ${graph.ownEnumerations.length}, association: ${graph.ownAssociations.length}, profile: ${graph.ownProfiles.length}, functions: ${graph.ownFunctions.length}]`,
-        );
-      }
-      stepStartTime = stepFinishedTime;
-
-      // Stores
-      yield flowResult(this.buildStores(graph, graphBuilderInput, options));
-      stepFinishedTime = Date.now();
-      // TODO: we might want to detail out the number of stores by type
-      if (!options?.quiet) {
-        this.log.info(
-          LogEvent.create(GRAPH_MANAGER_LOG_EVENT.GRAPH_BUILDER_STORES_BUILT),
-          stepFinishedTime - stepStartTime,
-          'ms',
-          `[store: ${graph.ownStores.length}]`,
-        );
-      }
-      stepStartTime = stepFinishedTime;
-
-      // Mappings
-      yield flowResult(this.buildMappings(graph, graphBuilderInput, options));
-      stepFinishedTime = Date.now();
-      if (!options?.quiet) {
-        this.log.info(
-          LogEvent.create(GRAPH_MANAGER_LOG_EVENT.GRAPH_BUILDER_MAPPINGS_BUILT),
-          stepFinishedTime - stepStartTime,
-          'ms',
-          `[mapping: ${graph.ownMappings.length}]`,
-        );
-      }
-      stepStartTime = stepFinishedTime;
-
-      // Connections and runtimes
-      yield flowResult(
-        this.buildConnectionsAndRuntimes(graph, graphBuilderInput, options),
-      );
-      stepFinishedTime = Date.now();
-      if (!options?.quiet) {
-        this.log.info(
-          LogEvent.create(
-            GRAPH_MANAGER_LOG_EVENT.GRAPH_BUILDER_CONNECTIONS_BUILT,
-          ),
-          stepFinishedTime - stepStartTime,
-          'ms',
-          `[connection: ${graph.ownConnections.length}]`,
-        );
-        this.log.info(
-          LogEvent.create(GRAPH_MANAGER_LOG_EVENT.GRAPH_BUILDER_RUNTIMES_BUILT),
-          stepFinishedTime - stepStartTime,
-          'ms',
-          `[runtime: ${graph.ownRuntimes.length}]`,
-        );
-      }
-      stepStartTime = stepFinishedTime;
-
-      // Services
-      yield flowResult(this.buildServices(graph, graphBuilderInput, options));
-      stepFinishedTime = Date.now();
-      if (!options?.quiet) {
-        this.log.info(
-          LogEvent.create(GRAPH_MANAGER_LOG_EVENT.GRAPH_BUILDER_SERVICES_BUILT),
-          stepFinishedTime - stepStartTime,
-          'ms',
-          `[service: ${graph.ownServices.length}]`,
-        );
-      }
-      stepStartTime = stepFinishedTime;
-
-      // File Generation
-      yield flowResult(
-        this.buildFileGenerations(graph, graphBuilderInput, options),
-      );
-      stepFinishedTime = Date.now();
-      if (!options?.quiet) {
-        this.log.info(
-          LogEvent.create(
-            GRAPH_MANAGER_LOG_EVENT.GRAPH_BUILDER_FILE_GENERATIONS_BUILT,
-          ),
-          stepFinishedTime - stepStartTime,
-          'ms',
-          `[file-generation: ${graph.ownFileGenerations.length}]`,
-        );
-      }
-      stepStartTime = stepFinishedTime;
-
-      // Generation Specifications (tree)
-      yield flowResult(
-        this.buildGenerationSpecificationss(graph, graphBuilderInput, options),
-      );
-      stepFinishedTime = Date.now();
-      if (!options?.quiet) {
-        this.log.info(
-          LogEvent.create(
-            GRAPH_MANAGER_LOG_EVENT.GRAPH_BUILDER_GENERATION_TREE_BUILT,
-          ),
-          stepFinishedTime - stepStartTime,
-          'ms',
-          `[generation-specification: ${graph.ownGenerationSpecifications.length}]`,
-        );
-      }
-      stepStartTime = stepFinishedTime;
 
-      // Other elements
+      // build
       yield flowResult(
-        this.buildOtherElements(graph, graphBuilderInput, options),
+        this.buildGraphFromInputs(
+          graph,
+          buildInputs,
+          report,
+          stopWatch,
+          graphBuilderState,
+          options,
+        ),
       );
-      stepFinishedTime = Date.now();
-      if (!options?.quiet) {
-        this.log.info(
-          LogEvent.create(
-            GRAPH_MANAGER_LOG_EVENT.GRAPH_BUILDER_OTHER_ELEMENTS_BUILT,
-          ),
-          stepFinishedTime - stepStartTime,
-          'ms',
-        );
-      }
 
-      yield flowResult(
-        this.postProcess(graph, graphBuilderInput, {
-          TEMPORARY__keepSectionIndex: options?.TEMPORARY__keepSectionIndex,
-        }),
-      );
-      graph.buildState.pass();
-      if (!options?.quiet) {
-        this.log.info(
-          LogEvent.create(GRAPH_MANAGER_LOG_EVENT.GRAPH_BUILDER_COMPLETED),
-          '[TOTAL]',
-          Date.now() - startTime,
-          'ms',
-        );
-      }
+      graphBuilderState.pass();
+      report.timings = {
+        ...Object.fromEntries(stopWatch.records),
+        [GRAPH_MANAGER_EVENT.GRAPH_BUILDER_COMPLETED]: stopWatch.elapsed,
+      };
+      return report;
     } catch (error) {
       assertErrorThrown(error);
-      if (!options?.quiet) {
-        this.log.info(
-          LogEvent.create(GRAPH_MANAGER_LOG_EVENT.GRAPH_BUILDER_FAILURE),
-          '[ERROR]',
-          Date.now() - startTime,
-          'ms',
-        );
-      }
-      graph.buildState.fail();
+      this.log.error(
+        LogEvent.create(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_FAILURE),
+      );
+      graphBuilderState.fail();
       /**
        * Wrap all error with `GraphBuilderError`, as we throw a lot of assertion error in the graph builder
        * But we might want to rethink this decision in the future and throw appropriate type of error
@@ -854,6 +717,8 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
       throw error instanceof GraphBuilderError
         ? error
         : new GraphBuilderError(error);
+    } finally {
+      graphBuilderState.setMessage(undefined);
     }
   }
 
@@ -861,18 +726,16 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     graph: PureModel,
     generatedEntities: Map<string, Entity[]>,
     options?: GraphBuilderOptions,
-  ): GeneratorFn<void> {
-    const stepStartTime = Date.now();
+  ): GeneratorFn<GraphBuilderReport> {
+    const stopWatch = new StopWatch();
+    const report = new GraphBuilderReport();
     const generatedModel = graph.generationModel;
-    generatedModel.buildState.reset();
+    const graphBuilderState = generatedModel.buildState;
+    graphBuilderState.reset();
+
     try {
-      if (!options?.quiet) {
-        this.log.info(
-          LogEvent.create(
-            GRAPH_MANAGER_LOG_EVENT.GRAPH_BUILDER_DATA_MODEL_PARSED,
-          ),
-        );
-      }
+      // deserialize
+      graphBuilderState.setMessage(`Deserializing elements...`);
       const generatedDataMap = new Map<string, V1_PureModelContextData>();
       yield Promise.all(
         Array.from(generatedEntities.entries()).map(
@@ -887,57 +750,46 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
           },
         ),
       );
-      const generationGraphBuilderInput = Array.from(
-        generatedDataMap.entries(),
-      ).map(([generationParentPath, generatedData]) => ({
-        parentElementPath: generationParentPath,
-        data: indexPureModelContextData(generatedData, this.extensions),
-        model: generatedModel,
-      }));
-
-      yield flowResult(
-        this.initializeAndIndexElements(graph, generationGraphBuilderInput),
+      stopWatch.record(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_ELEMENTS_DESERIALIZED);
+
+      // prepare build inputs
+      const buildInputs = Array.from(generatedDataMap.entries()).map(
+        ([generationParentPath, generatedData]) => ({
+          parentElementPath: generationParentPath,
+          data: indexPureModelContextData(
+            report,
+            generatedData,
+            this.extensions,
+          ),
+          model: generatedModel,
+        }),
       );
 
-      yield flowResult(this.buildTypes(graph, generationGraphBuilderInput));
-      yield flowResult(this.buildStores(graph, generationGraphBuilderInput));
-      yield flowResult(this.buildMappings(graph, generationGraphBuilderInput));
-      yield flowResult(
-        this.buildConnectionsAndRuntimes(graph, generationGraphBuilderInput),
-      );
-      yield flowResult(this.buildServices(graph, generationGraphBuilderInput));
-      yield flowResult(
-        this.buildFileGenerations(graph, generationGraphBuilderInput),
-      );
-      yield flowResult(
-        this.buildGenerationSpecificationss(graph, generationGraphBuilderInput),
-      );
+      // build
       yield flowResult(
-        this.buildOtherElements(graph, generationGraphBuilderInput),
+        this.buildGraphFromInputs(
+          graph,
+          buildInputs,
+          report,
+          stopWatch,
+          graphBuilderState,
+          options,
+        ),
       );
 
-      yield flowResult(this.postProcess(graph, generationGraphBuilderInput));
-      generatedModel.buildState.pass();
-      if (!options?.quiet) {
-        this.log.info(
-          LogEvent.create(
-            GRAPH_MANAGER_LOG_EVENT.GRAPH_BUILDER_GENERATIONS_BUILT,
-          ),
-          Date.now() - stepStartTime,
-          `${graph.generationModel.allOwnElements.length} generated elements processed`,
-          'ms',
-        );
-      }
+      graphBuilderState.pass();
+      report.otherStats.generationCount = generatedDataMap.size;
+      report.timings = {
+        ...Object.fromEntries(stopWatch.records),
+        [GRAPH_MANAGER_EVENT.GRAPH_BUILDER_COMPLETED]: stopWatch.elapsed,
+      };
+      return report;
     } catch (error) {
       assertErrorThrown(error);
-      if (!options?.quiet) {
-        this.log.info(
-          LogEvent.create(GRAPH_MANAGER_LOG_EVENT.GRAPH_BUILDER_FAILURE),
-          Date.now() - stepStartTime,
-          'ms',
-        );
-      }
-      generatedModel.buildState.fail();
+      this.log.error(
+        LogEvent.create(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_FAILURE),
+      );
+      graphBuilderState.fail();
       /**
        * Wrap all error with `GraphBuilderError`, as we throw a lot of assertion error in the graph builder
        * But we might want to rethink this decision in the future and throw appropriate type of error
@@ -945,9 +797,77 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
       throw error instanceof GraphBuilderError
         ? error
         : new GraphBuilderError(error);
+    } finally {
+      graphBuilderState.setMessage(undefined);
     }
   }
 
+  private *buildGraphFromInputs(
+    graph: PureModel,
+    inputs: V1_GraphBuilderInput[],
+    report: GraphBuilderReport,
+    stopWatch: StopWatch,
+    graphBuilderState: ActionState,
+    options?: GraphBuilderOptions,
+  ): GeneratorFn<void> {
+    // index
+    graphBuilderState.setMessage(
+      `Indexing ${report.elementCount.total} elements...`,
+    );
+    yield flowResult(this.initializeAndIndexElements(graph, inputs, options));
+    stopWatch.record(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_ELEMENTS_INDEXED);
+
+    // build section index
+    graphBuilderState.setMessage(`Building section indices...`);
+    yield flowResult(this.buildSectionIndices(graph, inputs, options));
+    stopWatch.record(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_SECTION_INDICES_BUILT);
+
+    // build types
+    graphBuilderState.setMessage(`Building domain models...`);
+    yield flowResult(this.buildTypes(graph, inputs, options));
+    stopWatch.record(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_DOMAIN_MODELS_BUILT);
+
+    // build stores
+    graphBuilderState.setMessage(`Building stores...`);
+    yield flowResult(this.buildStores(graph, inputs, options));
+    stopWatch.record(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_STORES_BUILT);
+
+    // build mappings
+    graphBuilderState.setMessage(`Building mappings...`);
+    yield flowResult(this.buildMappings(graph, inputs, options));
+    stopWatch.record(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_MAPPINGS_BUILT);
+
+    // build connections and runtimes
+    graphBuilderState.setMessage(`Building connections and runtimes...`);
+    yield flowResult(this.buildConnectionsAndRuntimes(graph, inputs, options));
+    stopWatch.record(
+      GRAPH_MANAGER_EVENT.GRAPH_BUILDER_CONNECTIONS_AND_RUNTIMES_BUILT,
+    );
+
+    // build services
+    graphBuilderState.setMessage(`Building services...`);
+    yield flowResult(this.buildServices(graph, inputs, options));
+    stopWatch.record(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_SERVICES_BUILT);
+
+    // build other elements
+    graphBuilderState.setMessage(`Building other elements...`);
+    yield flowResult(this.buildFileGenerations(graph, inputs, options));
+    yield flowResult(
+      this.buildGenerationSpecifications(graph, inputs, options),
+    );
+    yield flowResult(this.buildOtherElements(graph, inputs, options));
+    stopWatch.record(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_OTHER_ELEMENTS_BUILT);
+
+    // post-process
+    graphBuilderState.setMessage(`Post-processing graph...`);
+    yield flowResult(
+      this.postProcess(graph, inputs, {
+        TEMPORARY__keepSectionIndex: options?.TEMPORARY__keepSectionIndex,
+      }),
+    );
+    stopWatch.record(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_POST_PROCESSED);
+  }
+
   private getBuilderContext(
     graph: PureModel,
     currentSubGraph: BasicModel,
@@ -1332,7 +1252,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     );
   }
 
-  private *buildGenerationSpecificationss(
+  private *buildGenerationSpecifications(
     graph: PureModel,
     inputs: V1_GraphBuilderInput[],
     options?: GraphBuilderOptions,
@@ -1351,7 +1271,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     );
   }
 
-  private *buildSectionIndex(
+  private *buildSectionIndices(
     graph: PureModel,
     inputs: V1_GraphBuilderInput[],
     options?: GraphBuilderOptions,
@@ -1479,9 +1399,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
       graphData,
     );
     this.log.info(
-      LogEvent.create(
-        GRAPH_MANAGER_LOG_EVENT.GRAPH_MODEL_TO_GRAMMAR_TRANSFORMED,
-      ),
+      LogEvent.create(GRAPH_MANAGER_EVENT.GRAPH_MODEL_TO_GRAMMAR_TRANSFORMED),
       Date.now() - startTime,
       'ms',
     );
@@ -1494,9 +1412,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
       await this.entitiesToPureModelContextData(entities),
     );
     this.log.info(
-      LogEvent.create(
-        GRAPH_MANAGER_LOG_EVENT.GRAPH_MODEL_TO_GRAMMAR_TRANSFORMED,
-      ),
+      LogEvent.create(GRAPH_MANAGER_EVENT.GRAPH_MODEL_TO_GRAMMAR_TRANSFORMED),
       Date.now() - startTime,
       'ms',
     );
@@ -1816,7 +1732,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     );
   }
 
-  pureProtocolToEntities = (protocol: string): Entity[] => {
+  pureProtocolTextToEntities = (protocol: string): Entity[] => {
     const graphData = V1_deserializePureModelContextData(JSON.parse(protocol));
     return this.pureModelContextDataToEntities(graphData);
   };
@@ -2119,6 +2035,234 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     );
   }
 
+  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.extensions),
+      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.extensions),
+      },
+    ];
+    const graphBuilderInput = [
+      ...dependencyGraphBuilderInput,
+      ...mainGraphBuilderInput,
+    ];
+    await flowResult(this.initializeAndIndexElements(graph, graphBuilderInput));
+    return graphBuilderInput;
+  }
+
+  // We could optimize this further by omitting parts of the entities we don't need
+  async buildGraphForCreateQuerySetup(
+    graph: PureModel,
+    entities: Entity[],
+    dependencyEntities: Map<string, Entity[]>,
+  ): Promise<void> {
+    try {
+      const graphBuilderInput = await this.indexEntitiesWithDependencyIntoGraph(
+        graph,
+        entities,
+        dependencyEntities,
+        (entity: Entity): boolean =>
+          ((entity.content as PlainObject<V1_PackageableElement>)
+            ._type as string) === V1_MAPPING_ELEMENT_PROTOCOL_TYPE ||
+          ((entity.content as PlainObject<V1_PackageableElement>)
+            ._type as string) === V1_PACKAGEABLE_RUNTIME_ELEMENT_PROTOCOL_TYPE,
+      );
+      // handle mapping includes
+      const mappings = [
+        ...graph.ownMappings,
+        ...graph.dependencyManager.mappings,
+      ];
+      const v1Mappings = graphBuilderInput
+        .map((e) =>
+          e.data.elements.filter(
+            (type: V1_PackageableElement): type is V1_Mapping =>
+              type instanceof V1_Mapping,
+          ),
+        )
+        .flat();
+      const context = new V1_GraphBuilderContextBuilder(
+        graph,
+        graph,
+        this.extensions,
+        this.log,
+      ).build();
+      // build include index for compatible runtime analysis
+      v1Mappings.forEach((element) => {
+        const mapping = mappings.find((e) => e.path === element.path);
+        if (mapping) {
+          mapping.includes = element.includedMappings.map((i) => {
+            assertNonEmptyString(
+              i.includedMappingPath,
+              `Mapping include 'includedMappingPath' field is missing or empty`,
+            );
+            return new MappingInclude(
+              mapping,
+              context.resolveMapping(i.includedMappingPath),
+            );
+          });
+        }
+      });
+      // handle runtimes
+      const runtimes = [
+        ...graph.ownRuntimes,
+        ...graph.dependencyManager.runtimes,
+      ];
+      const v1Runtimes = graphBuilderInput
+        .map((e) =>
+          e.data.elements.filter(
+            (type: V1_PackageableElement): type is V1_PackageableRuntime =>
+              type instanceof V1_PackageableRuntime,
+          ),
+        )
+        .flat();
+      v1Runtimes.forEach((element) => {
+        const runtime = runtimes.find((e) => e.path === element.path);
+        if (runtime) {
+          const runtimeValue = new EngineRuntime();
+          runtime.setRuntimeValue(runtimeValue);
+          runtimeValue.setMappings(
+            element.runtimeValue.mappings.map((mapping) =>
+              context.resolveMapping(mapping.path),
+            ),
+          );
+        }
+      });
+      graph.buildState.pass();
+    } catch (error) {
+      assertErrorThrown(error);
+      graph.buildState.fail();
+      /**
+       * Wrap all error with `GraphBuilderError`, as we throw a lot of assertion error in the graph builder
+       * But we might want to rethink this decision in the future and throw appropriate type of error
+       */
+      throw error instanceof GraphBuilderError
+        ? error
+        : new GraphBuilderError(error);
+    }
+  }
+
+  // We could optimize this further by omitting parts of the entities we don't need
+  // i.e service entity would only keep execution
+  async buildGraphForServiceQuerySetup(
+    graph: PureModel,
+    entities: Entity[],
+    dependencyEntities: Map<string, Entity[]>,
+  ): Promise<void> {
+    try {
+      const graphBuilderInput = await this.indexEntitiesWithDependencyIntoGraph(
+        graph,
+        entities,
+        dependencyEntities,
+        (entity: Entity): boolean =>
+          ((entity.content as PlainObject<V1_PackageableElement>)
+            ._type as string) === V1_SERVICE_ELEMENT_PROTOCOL_TYPE,
+      );
+      // handle servicess
+      const services = [
+        ...graph.ownServices,
+        ...graph.dependencyManager.services,
+      ];
+      const v1Services = graphBuilderInput
+        .map((e) =>
+          e.data.elements.filter(
+            (type: V1_PackageableElement): type is V1_Service =>
+              type instanceof V1_Service,
+          ),
+        )
+        .flat();
+      // build service multi execution keys
+      v1Services.forEach((element) => {
+        const service = services.find((e) => e.path === element.path);
+        if (service) {
+          const serviceExecution = element.execution;
+          if (serviceExecution instanceof V1_PureMultiExecution) {
+            const execution = new PureMultiExecution(
+              serviceExecution.executionKey,
+              RawLambda.createStub(),
+              service,
+            );
+            execution.executionParameters =
+              serviceExecution.executionParameters.map(
+                (keyedExecutionParameter) =>
+                  new KeyedExecutionParameter(
+                    keyedExecutionParameter.key,
+                    PackageableElementExplicitReference.create(new Mapping('')),
+                    new EngineRuntime(),
+                  ),
+              );
+            service.setExecution(execution);
+          } else if (serviceExecution instanceof V1_PureSingleExecution) {
+            service.setExecution(
+              new PureSingleExecution(
+                RawLambda.createStub(),
+                service,
+                PackageableElementExplicitReference.create(new Mapping('')),
+                new EngineRuntime(),
+              ),
+            );
+          }
+        }
+      });
+      graph.buildState.pass();
+    } catch (error) {
+      assertErrorThrown(error);
+      graph.buildState.fail();
+      /**
+       * Wrap all error with `GraphBuilderError`, as we throw a lot of assertion error in the graph builder
+       * But we might want to rethink this decision in the future and throw appropriate type of error
+       */
+      throw error instanceof GraphBuilderError
+        ? error
+        : new GraphBuilderError(error);
+    }
+  }
+
   async getQuery(queryId: string, graph: PureModel): Promise<Query> {
     return V1_buildQuery(
       await this.engine.getQuery(queryId),
@@ -2374,7 +2518,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     );
     this.log.info(
       LogEvent.create(
-        GRAPH_MANAGER_LOG_EVENT.GRAPH_META_MODEL_TO_PROTOCOL_TRANSFORMED,
+        GRAPH_MANAGER_EVENT.GRAPH_META_MODEL_TO_PROTOCOL_TRANSFORMED,
       ),
       Date.now() - startTime,
       'ms',
@@ -2394,7 +2538,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
       ...generatedModel.allOwnElements,
     ].map((element) => this.elementToProtocol(element));
     this.log.info(
-      LogEvent.create(GRAPH_MANAGER_LOG_EVENT.GRAPH_COMPILE_CONTEXT_COLLECTED),
+      LogEvent.create(GRAPH_MANAGER_EVENT.GRAPH_COMPILE_CONTEXT_COLLECTED),
       Date.now() - startTime,
       'ms',
     );
@@ -2522,7 +2666,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     } catch (error) {
       assertErrorThrown(error);
       this.log.warn(
-        LogEvent.create(GRAPH_MANAGER_LOG_EVENT.GRAPH_MANAGER_FAILURE),
+        LogEvent.create(GRAPH_MANAGER_EVENT.GRAPH_MANAGER_FAILURE),
         `Can't extract assertion result`,
       );
       json = undefined;