@finos/legend-graph 2.1.1 → 3.0.0

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

@@ -13,9 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { flow, flowResult, makeObservable, runInAction } from 'mobx';
 import { GRAPH_MANAGER_EVENT } from '../../../../graphManager/GraphManagerEvent';
-import { CORE_PURE_PATH, ELEMENT_PATH_DELIMITER, ROOT_PACKAGE_NAME, SOURCE_INFORMATION_KEY, } from '../../../../MetaModelConst';
+import { CORE_PURE_PATH, ELEMENT_PATH_DELIMITER, SOURCE_INFORMATION_KEY, } from '../../../../MetaModelConst';
 import { TracerService, LogEvent, getClass, guaranteeNonNullable, UnsupportedOperationError, recursiveOmit, assertTrue, assertErrorThrown, promisify, StopWatch, assertNonEmptyString, } from '@finos/legend-shared';
 import { AbstractPureGraphManager, } from '../../../../graphManager/AbstractPureGraphManager';
 import { Mapping } from '../../../metamodels/pure/packageableElements/mapping/Mapping';
@@ -235,25 +234,6 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     extensions;
     constructor(pluginManager, log) {
         super(pluginManager, log);
-        makeObservable(this, {
-            initialize: flow,
-            buildSystem: flow,
-            buildDependencies: flow,
-            buildGraph: flow,
-            buildGraphFromInputs: flow,
-            buildGenerations: flow,
-            initializeAndIndexElements: flow,
-            postProcess: flow,
-            buildTypes: flow,
-            buildStores: flow,
-            buildMappings: flow,
-            buildConnectionsAndRuntimes: flow,
-            buildSectionIndices: flow,
-            buildOtherElements: flow,
-            buildServices: flow,
-            buildFileGenerations: flow,
-            buildGenerationSpecifications: flow,
-        });
         this.engine = new V1_Engine({}, log);
         // setup plugins
         this.extensions = new V1_GraphBuilderExtensions(this.pluginManager.getPureProtocolProcessorPlugins());
@@ -267,15 +247,15 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     TEMPORARY__getEngineConfig() {
         return this.engine.config;
     }
-    *initialize(config, options) {
+    async initialize(config, options) {
         this.engine = new V1_Engine(config.clientConfig, this.log);
         this.engine
             .getEngineServerClient()
             .setTracerService(options?.tracerService ?? new TracerService());
-        yield this.engine.setup(config);
+        await this.engine.setup(config);
     }
     // --------------------------------------------- Graph Builder ---------------------------------------------
-    *buildSystem(coreModel, systemModel, options) {
+    async buildSystem(coreModel, systemModel, options) {
         const stopWatch = new StopWatch();
         const report = new GraphBuilderReport();
         const graphBuilderState = systemModel.buildState;
@@ -298,7 +278,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
                 },
             ];
             // build
-            yield flowResult(this.buildGraphFromInputs(graph, buildInputs, report, stopWatch, graphBuilderState, options));
+            await this.buildGraphFromInputs(graph, buildInputs, report, stopWatch, graphBuilderState, options);
             graphBuilderState.pass();
             report.timings = {
                 ...Object.fromEntries(stopWatch.records),
@@ -316,7 +296,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
             graphBuilderState.setMessage(undefined);
         }
     }
-    *buildDependencies(coreModel, systemModel, dependencyManager, dependencyEntitiesMap, options) {
+    async buildDependencies(coreModel, systemModel, dependencyManager, dependencyEntitiesMap, options) {
         const stopWatch = new StopWatch();
         const report = new GraphBuilderReport();
         const graphBuilderState = dependencyManager.buildState;
@@ -329,7 +309,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
             // deserialize
             graphBuilderState.setMessage(`Partitioning and deserializing elements...`);
             const dependencyDataMap = new Map();
-            yield Promise.all(Array.from(dependencyEntitiesMap.entries()).map(([dependencyKey, entities]) => {
+            await Promise.all(Array.from(dependencyEntitiesMap.entries()).map(([dependencyKey, entities]) => {
                 const projectModelData = new V1_PureModelContextData();
                 dependencyDataMap.set(dependencyKey, projectModelData);
                 return V1_entitiesToPureModelContextData(entities, projectModelData, this.pluginManager.getPureProtocolProcessorPlugins());
@@ -341,7 +321,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
                 model: graph.dependencyManager.getModel(dependencyKey),
             }));
             // build
-            yield flowResult(this.buildGraphFromInputs(graph, buildInputs, report, stopWatch, graphBuilderState, options));
+            await this.buildGraphFromInputs(graph, buildInputs, report, stopWatch, graphBuilderState, options);
             graphBuilderState.pass();
             report.otherStats.projectCount = dependencyEntitiesMap.size;
             report.timings = {
@@ -360,7 +340,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
             graphBuilderState.setMessage(undefined);
         }
     }
-    *buildGraph(graph, entities, options) {
+    async buildGraph(graph, entities, options) {
         const stopWatch = new StopWatch();
         const report = new GraphBuilderReport();
         const graphBuilderState = graph.buildState;
@@ -369,7 +349,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
             // deserialize
             graphBuilderState.setMessage(`Deserializing elements...`);
             const data = new V1_PureModelContextData();
-            yield V1_entitiesToPureModelContextData(entities, data, this.pluginManager.getPureProtocolProcessorPlugins());
+            await V1_entitiesToPureModelContextData(entities, data, this.pluginManager.getPureProtocolProcessorPlugins());
             stopWatch.record(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_ELEMENTS_DESERIALIZED);
             // prepare build inputs
             const buildInputs = [
@@ -379,7 +359,15 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
                 },
             ];
             // build
-            yield flowResult(this.buildGraphFromInputs(graph, buildInputs, report, stopWatch, graphBuilderState, options));
+            await this.buildGraphFromInputs(graph, buildInputs, report, stopWatch, graphBuilderState, options);
+            /**
+             * For now, we delete the section index. We are able to read both resolved and unresolved element paths
+             * but when we write (serialize) we write only resolved paths. In the future once the issue with dependency is solved we will
+             * perserve the element path both resolved and unresolved
+             */
+            if (!options?.TEMPORARY__keepSectionIndex) {
+                graph.TEMPORARY__deleteOwnSectionIndex();
+            }
             graphBuilderState.pass();
             report.timings = {
                 ...Object.fromEntries(stopWatch.records),
@@ -403,7 +391,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
             graphBuilderState.setMessage(undefined);
         }
     }
-    *buildGenerations(graph, generatedEntities, options) {
+    async buildGenerations(graph, generatedEntities, options) {
         const stopWatch = new StopWatch();
         const report = new GraphBuilderReport();
         const generatedModel = graph.generationModel;
@@ -413,7 +401,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
             // deserialize
             graphBuilderState.setMessage(`Deserializing elements...`);
             const generatedDataMap = new Map();
-            yield Promise.all(Array.from(generatedEntities.entries()).map(([generationParentPath, entities]) => {
+            await Promise.all(Array.from(generatedEntities.entries()).map(([generationParentPath, entities]) => {
                 const generatedData = new V1_PureModelContextData();
                 generatedDataMap.set(generationParentPath, generatedData);
                 return V1_entitiesToPureModelContextData(entities, generatedData, this.pluginManager.getPureProtocolProcessorPlugins());
@@ -426,7 +414,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
                 model: generatedModel,
             }));
             // build
-            yield flowResult(this.buildGraphFromInputs(graph, buildInputs, report, stopWatch, graphBuilderState, options));
+            await this.buildGraphFromInputs(graph, buildInputs, report, stopWatch, graphBuilderState, options);
             graphBuilderState.pass();
             report.otherStats.generationCount = generatedDataMap.size;
             report.timings = {
@@ -451,45 +439,41 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
             graphBuilderState.setMessage(undefined);
         }
     }
-    *buildGraphFromInputs(graph, inputs, report, stopWatch, graphBuilderState, options) {
+    async buildGraphFromInputs(graph, inputs, report, stopWatch, graphBuilderState, options) {
         // index
         graphBuilderState.setMessage(`Indexing ${report.elementCount.total} elements...`);
-        yield flowResult(this.initializeAndIndexElements(graph, inputs, options));
+        await 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));
+        await 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));
+        await 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));
+        await 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));
+        await 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));
+        await 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));
+        await 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));
+        await this.buildFileGenerations(graph, inputs, options);
+        await this.buildGenerationSpecifications(graph, inputs, options);
+        await 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, options));
-        stopWatch.record(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_POST_PROCESSED);
     }
     getBuilderContext(graph, currentSubGraph, element, options) {
         return new V1_GraphBuilderContextBuilder(graph, currentSubGraph, this.extensions, this.log, options)
@@ -504,78 +488,55 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
      *
      * NOTE: We aim to not do anything more than running the first pass and indexing the first pass.
      */
-    *initializeAndIndexElements(graph, inputs, options) {
-        yield Promise.all(inputs.flatMap((input) => input.data.nativeElements.map((element) => this.visitWithErrorHandling(element, new V1_ProtocolToMetaModelGraphFirstPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
-        yield Promise.all(this.extensions.sortedExtraElementBuilders.map(async (builder) => {
+    async initializeAndIndexElements(graph, inputs, options) {
+        await Promise.all(inputs.flatMap((input) => input.data.nativeElements.map((element) => this.visitWithErrorHandling(element, new V1_ProtocolToMetaModelGraphFirstPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        await Promise.all(this.extensions.sortedExtraElementBuilders.map(async (builder) => {
             await Promise.all(inputs.flatMap((input) => (input.data.otherElementsByBuilder.get(builder) ?? []).map((element) => this.visitWithErrorHandling(element, new V1_ProtocolToMetaModelGraphFirstPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
         }));
     }
-    /**
-     * Run post-processers on elements of the graph.
-     */
-    *postProcess(graph, inputs, options) {
-        if (!options?.TEMPORARY_skipGraphBuilderPostProcessing) {
-            yield Promise.all(inputs.flatMap((input) => input.data.elements.map((el) => promisify(() => runInAction(() => {
-                // TODO: check performance once `getNullableElement` is optimized
-                const element = graph.getElement(el.path);
-                const isElementReadOnly = Boolean(element.getRoot().path !== ROOT_PACKAGE_NAME.MAIN);
-                if (isElementReadOnly) {
-                    element.freeze();
-                }
-            })))));
-        }
-        /**
-         * For now, we delete the section index. We are able to read both resolved and unresolved element paths
-         * but when we write (serialize) we write only resolved paths. In the future once the issue with dependency is solved we will
-         * perserve the element path both resolved and unresolved
-         */
-        if (!options?.TEMPORARY__keepSectionIndex) {
-            graph.TEMPORARY__deleteOwnSectionIndex();
-        }
-    }
-    *buildTypes(graph, inputs, options) {
+    async buildTypes(graph, inputs, options) {
         // Second pass
-        yield Promise.all(inputs.flatMap((input) => input.data.profiles.map((element) => this.visitWithErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
-        yield Promise.all(inputs.flatMap((input) => input.data.classes.map((element) => this.visitWithErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
-        yield Promise.all(inputs.flatMap((input) => input.data.enumerations.map((element) => this.visitWithErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
-        yield Promise.all(inputs.flatMap((input) => input.data.measures.map((element) => this.visitWithErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
-        yield Promise.all(inputs.flatMap((input) => input.data.functions.map((element) => this.visitWithErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        await Promise.all(inputs.flatMap((input) => input.data.profiles.map((element) => this.visitWithErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        await Promise.all(inputs.flatMap((input) => input.data.classes.map((element) => this.visitWithErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        await Promise.all(inputs.flatMap((input) => input.data.enumerations.map((element) => this.visitWithErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        await Promise.all(inputs.flatMap((input) => input.data.measures.map((element) => this.visitWithErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        await Promise.all(inputs.flatMap((input) => input.data.functions.map((element) => this.visitWithErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
         // Third pass
-        yield Promise.all(inputs.flatMap((input) => input.data.classes.map((element) => this.visitWithErrorHandling(element, new V1_ProtocolToMetaModelGraphThirdPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
-        yield Promise.all(inputs.flatMap((input) => input.data.associations.map((element) => this.visitWithErrorHandling(element, new V1_ProtocolToMetaModelGraphThirdPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        await Promise.all(inputs.flatMap((input) => input.data.classes.map((element) => this.visitWithErrorHandling(element, new V1_ProtocolToMetaModelGraphThirdPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        await Promise.all(inputs.flatMap((input) => input.data.associations.map((element) => this.visitWithErrorHandling(element, new V1_ProtocolToMetaModelGraphThirdPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
         // Fifth pass
-        yield Promise.all(inputs.flatMap((input) => input.data.classes.map((element) => this.visitWithErrorHandling(element, new V1_ProtocolToMetaModelGraphFifthPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        await Promise.all(inputs.flatMap((input) => input.data.classes.map((element) => this.visitWithErrorHandling(element, new V1_ProtocolToMetaModelGraphFifthPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
     }
-    *buildStores(graph, inputs, options) {
-        yield Promise.all(inputs.flatMap((input) => input.data.stores.map((element) => this.visitWithErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
-        yield Promise.all(inputs.flatMap((input) => input.data.stores.map((element) => this.visitWithErrorHandling(element, new V1_ProtocolToMetaModelGraphThirdPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
-        yield Promise.all(inputs.flatMap((input) => input.data.stores.map((element) => this.visitWithErrorHandling(element, new V1_ProtocolToMetaModelGraphFourthPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
-        yield Promise.all(inputs.flatMap((input) => input.data.stores.map((element) => this.visitWithErrorHandling(element, new V1_ProtocolToMetaModelGraphFifthPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+    async buildStores(graph, inputs, options) {
+        await Promise.all(inputs.flatMap((input) => input.data.stores.map((element) => this.visitWithErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        await Promise.all(inputs.flatMap((input) => input.data.stores.map((element) => this.visitWithErrorHandling(element, new V1_ProtocolToMetaModelGraphThirdPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        await Promise.all(inputs.flatMap((input) => input.data.stores.map((element) => this.visitWithErrorHandling(element, new V1_ProtocolToMetaModelGraphFourthPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        await Promise.all(inputs.flatMap((input) => input.data.stores.map((element) => this.visitWithErrorHandling(element, new V1_ProtocolToMetaModelGraphFifthPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
     }
-    *buildMappings(graph, inputs, options) {
-        yield Promise.all(inputs.flatMap((input) => input.data.mappings.map((element) => this.visitWithErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
-        yield Promise.all(inputs.flatMap((input) => input.data.mappings.map((element) => this.visitWithErrorHandling(element, new V1_ProtocolToMetaModelGraphThirdPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
-        yield Promise.all(inputs.flatMap((input) => input.data.mappings.map((element) => this.visitWithErrorHandling(element, new V1_ProtocolToMetaModelGraphFourthPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+    async buildMappings(graph, inputs, options) {
+        await Promise.all(inputs.flatMap((input) => input.data.mappings.map((element) => this.visitWithErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        await Promise.all(inputs.flatMap((input) => input.data.mappings.map((element) => this.visitWithErrorHandling(element, new V1_ProtocolToMetaModelGraphThirdPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        await Promise.all(inputs.flatMap((input) => input.data.mappings.map((element) => this.visitWithErrorHandling(element, new V1_ProtocolToMetaModelGraphFourthPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
     }
-    *buildConnectionsAndRuntimes(graph, inputs, options) {
+    async buildConnectionsAndRuntimes(graph, inputs, options) {
         // NOTE: connections must be built before runtimes
-        yield Promise.all(inputs.flatMap((input) => input.data.connections.map((element) => this.visitWithErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
-        yield Promise.all(inputs.flatMap((input) => input.data.runtimes.map((element) => this.visitWithErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        await Promise.all(inputs.flatMap((input) => input.data.connections.map((element) => this.visitWithErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        await Promise.all(inputs.flatMap((input) => input.data.runtimes.map((element) => this.visitWithErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
     }
-    *buildServices(graph, inputs, options) {
-        yield Promise.all(inputs.flatMap((input) => input.data.services.map((element) => this.visitWithErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+    async buildServices(graph, inputs, options) {
+        await Promise.all(inputs.flatMap((input) => input.data.services.map((element) => this.visitWithErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
     }
-    *buildFileGenerations(graph, inputs, options) {
-        yield Promise.all(inputs.flatMap((input) => input.data.fileGenerations.map((element) => this.visitWithErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+    async buildFileGenerations(graph, inputs, options) {
+        await Promise.all(inputs.flatMap((input) => input.data.fileGenerations.map((element) => this.visitWithErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
     }
-    *buildGenerationSpecifications(graph, inputs, options) {
-        yield Promise.all(inputs.flatMap((input) => input.data.generationSpecifications.map((element) => this.visitWithErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+    async buildGenerationSpecifications(graph, inputs, options) {
+        await Promise.all(inputs.flatMap((input) => input.data.generationSpecifications.map((element) => this.visitWithErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
     }
-    *buildSectionIndices(graph, inputs, options) {
-        yield Promise.all(inputs.flatMap((input) => input.data.sectionIndices.map((element) => this.visitWithErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+    async buildSectionIndices(graph, inputs, options) {
+        await Promise.all(inputs.flatMap((input) => input.data.sectionIndices.map((element) => this.visitWithErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
     }
-    *buildOtherElements(graph, inputs, options) {
-        yield Promise.all(this.extensions.sortedExtraElementBuilders.map(async (builder) => {
+    async buildOtherElements(graph, inputs, options) {
+        await Promise.all(this.extensions.sortedExtraElementBuilders.map(async (builder) => {
             await Promise.all(inputs.flatMap((input) => (input.data.otherElementsByBuilder.get(builder) ?? []).map((element) => this.visitWithErrorHandling(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.visitWithErrorHandling(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.visitWithErrorHandling(element, new V1_ProtocolToMetaModelGraphFourthPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
@@ -584,7 +545,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     }
     visitWithErrorHandling(element, visitor) {
         try {
-            return promisify(() => runInAction(() => element.accept_PackageableElementVisitor(visitor)));
+            return promisify(() => element.accept_PackageableElementVisitor(visitor));
         }
         catch (err) {
             assertErrorThrown(err);
@@ -938,7 +899,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
             ...dependencyGraphBuilderInput,
             ...mainGraphBuilderInput,
         ];
-        await flowResult(this.initializeAndIndexElements(graph, graphBuilderInput));
+        await this.initializeAndIndexElements(graph, graphBuilderInput);
         return graphBuilderInput;
     }
     // We could optimize this further by omitting parts of the entities we don't need
@@ -979,8 +940,8 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
                 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)));
+                    runtime.runtimeValue = runtimeValue;
+                    runtimeValue.mappings = element.runtimeValue.mappings.map((mapping) => context.resolveMapping(mapping.path));
                 }
             });
             graph.buildState.pass();
@@ -1020,10 +981,10 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
                         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);
+                        service.execution = execution;
                     }
                     else if (serviceExecution instanceof V1_PureSingleExecution) {
-                        service.setExecution(new PureSingleExecution(RawLambda.createStub(), service, PackageableElementExplicitReference.create(new Mapping('')), new EngineRuntime()));
+                        service.execution = new PureSingleExecution(RawLambda.createStub(), service, PackageableElementExplicitReference.create(new Mapping('')), new EngineRuntime());
                     }
                 }
             });
@@ -1061,7 +1022,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         const hashMap = new Map();
         const pureModelContextData = new V1_PureModelContextData();
         await V1_entitiesToPureModelContextData(entities, pureModelContextData, this.pluginManager.getPureProtocolProcessorPlugins());
-        await Promise.all(pureModelContextData.elements.map((element) => promisify(() => runInAction(() => hashMap.set(element.path, element.hashCode)))));
+        await Promise.all(pureModelContextData.elements.map((element) => promisify(() => hashMap.set(element.path, element.hashCode))));
         return hashMap;
     }
     // ------------------------------------------- Raw Protocol Handling -------------------------------------------