@finos/legend-graph 5.0.0 → 7.0.0

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

@@ -19,12 +19,14 @@ import {
   CORE_PURE_PATH,
   ELEMENT_PATH_DELIMITER,
   SOURCE_INFORMATION_KEY,
+  PackageableElementPointerType,
 } from '../../../../MetaModelConst';
 import {
   type Clazz,
   type Log,
   type PlainObject,
   type ServerClientConfig,
+  type ActionState,
   TracerService,
   LogEvent,
   getClass,
@@ -34,10 +36,10 @@ import {
   assertTrue,
   assertErrorThrown,
   promisify,
-  type ActionState,
   StopWatch,
-  assertNonEmptyString,
   filterByType,
+  isNonNullable,
+  guaranteeNonEmptyString,
 } from '@finos/legend-shared';
 import type { TEMPORARY__AbstractEngineConfig } from '../../../../graphManager/action/TEMPORARY__AbstractEngineConfig';
 import {
@@ -66,13 +68,12 @@ import type { DependencyManager } from '../../../../graph/DependencyManager';
 import type { Class } from '../../../metamodels/pure/packageableElements/domain/Class';
 import { RawLambda } from '../../../metamodels/pure/rawValueSpecification/RawLambda';
 import type { RawValueSpecification } from '../../../metamodels/pure/rawValueSpecification/RawValueSpecification';
-import type { Service } from '../../../metamodels/pure/packageableElements/service/Service';
 import type { FileGenerationSpecification } from '../../../metamodels/pure/packageableElements/fileGeneration/FileGenerationSpecification';
 import type {
   GenerationConfigurationDescription,
   GenerationMode,
 } from '../../../../graphManager/action/generation/GenerationConfigurationDescription';
-import type { ServiceTestResult } from '../../../../graphManager/action/service/ServiceTestResult';
+import type { DEPRECATED__ServiceTestResult } from '../../../../graphManager/action/service/DEPRECATED__ServiceTestResult';
 import type { ServiceRegistrationResult } from '../../../../graphManager/action/service/ServiceRegistrationResult';
 import type { ExecutionResult } from '../../../../graphManager/action/execution/ExecutionResult';
 import type { GenerationOutput } from '../../../../graphManager/action/generation/GenerationOutput';
@@ -103,7 +104,6 @@ import { V1_PureModelContextData } from './model/context/V1_PureModelContextData
 import {
   type V1_PackageableElement,
   type V1_PackageableElementVisitor,
-  V1_PackageableElementPointerType,
   V1_PackageableElementPointer,
 } from './model/packageableElements/V1_PackageableElement';
 import { V1_ProtocolToMetaModelGraphFirstPassBuilder } from './transformation/pureGraph/to/V1_ProtocolToMetaModelGraphFirstPassBuilder';
@@ -126,7 +126,10 @@ import {
 } from './transformation/pureGraph/from/V1_RawValueSpecificationTransformer';
 import { V1_transformRuntime } from './transformation/pureGraph/from/V1_RuntimeTransformer';
 import type { V1_RawLambda } from './model/rawValueSpecification/V1_RawLambda';
-import { V1_ExecuteInput } from './engine/execution/V1_ExecuteInput';
+import {
+  V1_ExecuteInput,
+  V1_TestDataGenerationExecutionInput,
+} from './engine/execution/V1_ExecuteInput';
 import type { V1_PureModelContextGenerationInput } from './engine/import/V1_PureModelContextGenerationInput';
 import { V1_buildValueSpecification } from './transformation/pureGraph/to/helpers/V1_ValueSpecificationBuilderHelper';
 import { V1_transformRootValueSpecification } from './transformation/pureGraph/from/V1_ValueSpecificationTransformer';
@@ -198,7 +201,7 @@ import type {
 } from '../../../../graphManager/action/query/Query';
 import {
   V1_buildQuery,
-  V1_buildServiceTestResult,
+  V1_buildLegacyServiceTestResult,
   V1_buildServiceRegistrationResult,
   V1_transformQuery,
   V1_buildGenerationOutput,
@@ -235,6 +238,23 @@ import { MappingInclude } from '../../../metamodels/pure/packageableElements/map
 import type { ModelGenerationConfiguration } from '../../../ModelGenerationConfiguration';
 import type { MappingGeneration_PureProtocolProcessorPlugin_Extension } from '../MappingGeneration_PureProtocolProcessorPlugin_Extension';
 import type { Package } from '../../../metamodels/pure/packageableElements/domain/Package';
+import { V1_DataElement } from './model/packageableElements/data/V1_DataElement';
+import {
+  V1_RunTestsInput,
+  V1_RunTestsTestableInput,
+} from './engine/test/V1_RunTestsInput';
+import { V1_AtomicTestId } from './model/test/V1_AtomicTestId';
+import type { RunTestsTestableInput } from '../../../metamodels/pure/test/result/RunTestsTestableInput';
+import { V1_buildTestsResult } from './engine/test/V1_RunTestsResult';
+import type { TestResult } from '../../../metamodels/pure/test/result/TestResult';
+import type { Service } from '../../../../DSLService_Exports';
+import type { Testable } from '../../../metamodels/pure/test/Testable';
+import { stub_RawLambda } from '../../../../graphManager/action/creation/RawValueSpecificationCreatorHelper';
+import {
+  getNullableIDFromTestable,
+  getNullableTestable,
+} from '../../../../helpers/Testable_Helper';
+import { V1_getIncludedMappingPath } from './helper/V1_DSLMapping_Helper';
 
 const V1_FUNCTION_SUFFIX_MULTIPLICITY_INFINITE = 'MANY';
 
@@ -285,6 +305,8 @@ class V1_PureModelContextDataIndex {
   fileGenerations: V1_FileGenerationSpecification[] = [];
   generationSpecifications: V1_GenerationSpecification[] = [];
 
+  dataElements: V1_DataElement[] = [];
+
   otherElementsByBuilder: Map<
     V1_ElementBuilder<V1_PackageableElement>,
     V1_PackageableElement[]
@@ -347,6 +369,8 @@ const indexPureModelContextData = (
       index.fileGenerations.push(el);
     } else if (el instanceof V1_GenerationSpecification) {
       index.generationSpecifications.push(el);
+    } else if (el instanceof V1_DataElement) {
+      index.dataElements.push(el);
     } else {
       const clazz = getClass<V1_PackageableElement>(el);
       if (otherElementsByClass.has(clazz)) {
@@ -472,12 +496,12 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
   async buildSystem(
     coreModel: CoreModel,
     systemModel: SystemModel,
+    buildState: ActionState,
     options?: GraphBuilderOptions,
   ): Promise<GraphBuilderReport> {
     const stopWatch = new StopWatch();
     const report = new GraphBuilderReport();
-    const graphBuilderState = systemModel.buildState;
-    graphBuilderState.reset();
+    buildState.reset();
 
     // Create a dummy graph for system processing. This is to ensure system model does not depend on the main graph
     const graph = new PureModel(
@@ -488,7 +512,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
 
     try {
       // deserialize
-      graphBuilderState.setMessage(`Collecting and deserializing elements...`);
+      buildState.setMessage(`Collecting and deserializing elements...`);
       const systemData = mergePureModelContextData(
         V1_deserializePureModelContextData(V1_CORE_SYSTEM_MODELS),
         ...this.pluginManager
@@ -514,11 +538,11 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         buildInputs,
         report,
         stopWatch,
-        graphBuilderState,
+        buildState,
         options,
       );
 
-      graphBuilderState.pass();
+      buildState.pass();
       report.timings = {
         ...Object.fromEntries(stopWatch.records),
         [GRAPH_MANAGER_EVENT.GRAPH_BUILDER_COMPLETED]: stopWatch.elapsed,
@@ -526,14 +550,14 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
       return report;
     } catch (error) {
       assertErrorThrown(error);
-      graphBuilderState.fail();
+      buildState.fail();
       this.log.error(
         LogEvent.create(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_FAILURE),
         error,
       );
       throw new SystemGraphBuilderError(error);
     } finally {
-      graphBuilderState.setMessage(undefined);
+      buildState.setMessage(undefined);
     }
   }
 
@@ -542,12 +566,12 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     systemModel: SystemModel,
     dependencyManager: DependencyManager,
     dependencyEntitiesMap: Map<string, Entity[]>,
+    buildState: ActionState,
     options?: GraphBuilderOptions,
   ): Promise<GraphBuilderReport> {
     const stopWatch = new StopWatch();
     const report = new GraphBuilderReport();
-    const graphBuilderState = dependencyManager.buildState;
-    graphBuilderState.reset();
+    buildState.reset();
 
     // Create a dummy graph for system processing. This is to ensure dependency models do not depend on the main graph
     const graph = new PureModel(
@@ -561,9 +585,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
       dependencyManager.initialize(dependencyEntitiesMap);
 
       // deserialize
-      graphBuilderState.setMessage(
-        `Partitioning and deserializing elements...`,
-      );
+      buildState.setMessage(`Partitioning and deserializing elements...`);
       const dependencyDataMap = new Map<string, V1_PureModelContextData>();
       await Promise.all(
         Array.from(dependencyEntitiesMap.entries()).map(
@@ -598,11 +620,11 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         buildInputs,
         report,
         stopWatch,
-        graphBuilderState,
+        buildState,
         options,
       );
 
-      graphBuilderState.pass();
+      buildState.pass();
       report.otherStats.projectCount = dependencyEntitiesMap.size;
       report.timings = {
         ...Object.fromEntries(stopWatch.records),
@@ -615,26 +637,26 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         LogEvent.create(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_FAILURE),
         error,
       );
-      graphBuilderState.fail();
+      buildState.fail();
       throw new DependencyGraphBuilderError(error);
     } finally {
-      graphBuilderState.setMessage(undefined);
+      buildState.setMessage(undefined);
     }
   }
 
   async buildGraph(
     graph: PureModel,
     entities: Entity[],
+    buildState: ActionState,
     options?: GraphBuilderOptions,
   ): Promise<GraphBuilderReport> {
     const stopWatch = new StopWatch();
     const report = new GraphBuilderReport();
-    const graphBuilderState = graph.buildState;
-    graphBuilderState.reset();
+    buildState.reset();
 
     try {
       // deserialize
-      graphBuilderState.setMessage(`Deserializing elements...`);
+      buildState.setMessage(`Deserializing elements...`);
       const data = new V1_PureModelContextData();
       await V1_entitiesToPureModelContextData(
         entities,
@@ -657,7 +679,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         buildInputs,
         report,
         stopWatch,
-        graphBuilderState,
+        buildState,
         options,
       );
 
@@ -670,7 +692,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         graph.TEMPORARY__deleteOwnSectionIndex();
       }
 
-      graphBuilderState.pass();
+      buildState.pass();
       report.timings = {
         ...Object.fromEntries(stopWatch.records),
         [GRAPH_MANAGER_EVENT.GRAPH_BUILDER_COMPLETED]: stopWatch.elapsed,
@@ -682,7 +704,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         LogEvent.create(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_FAILURE),
         error,
       );
-      graphBuilderState.fail();
+      buildState.fail();
       /**
        * Wrap all error with `GraphBuilderError`, as we throw a lot of assertion error in the graph builder
        * But we might want to rethink this decision in the future and throw appropriate type of error
@@ -691,24 +713,24 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         ? error
         : new GraphBuilderError(error);
     } finally {
-      graphBuilderState.setMessage(undefined);
+      buildState.setMessage(undefined);
     }
   }
 
   async buildGenerations(
     graph: PureModel,
     generatedEntities: Map<string, Entity[]>,
+    buildState: ActionState,
     options?: GraphBuilderOptions,
   ): Promise<GraphBuilderReport> {
     const stopWatch = new StopWatch();
     const report = new GraphBuilderReport();
     const generatedModel = graph.generationModel;
-    const graphBuilderState = generatedModel.buildState;
-    graphBuilderState.reset();
+    buildState.reset();
 
     try {
       // deserialize
-      graphBuilderState.setMessage(`Deserializing elements...`);
+      buildState.setMessage(`Deserializing elements...`);
       const generatedDataMap = new Map<string, V1_PureModelContextData>();
       await Promise.all(
         Array.from(generatedEntities.entries()).map(
@@ -739,11 +761,11 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         buildInputs,
         report,
         stopWatch,
-        graphBuilderState,
+        buildState,
         options,
       );
 
-      graphBuilderState.pass();
+      buildState.pass();
       report.otherStats.generationCount = generatedDataMap.size;
       report.timings = {
         ...Object.fromEntries(stopWatch.records),
@@ -756,7 +778,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         LogEvent.create(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_FAILURE),
         error,
       );
-      graphBuilderState.fail();
+      buildState.fail();
       /**
        * Wrap all error with `GraphBuilderError`, as we throw a lot of assertion error in the graph builder
        * But we might want to rethink this decision in the future and throw appropriate type of error
@@ -765,7 +787,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         ? error
         : new GraphBuilderError(error);
     } finally {
-      graphBuilderState.setMessage(undefined);
+      buildState.setMessage(undefined);
     }
   }
 
@@ -816,6 +838,11 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     await this.buildServices(graph, inputs, options);
     stopWatch.record(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_SERVICES_BUILT);
 
+    // build data elements
+    graphBuilderState.setMessage(`Building data elements...`);
+    await this.buildDataElements(graph, inputs, options);
+    stopWatch.record(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_DATA_ELEMENTS_BUILT);
+
     // build other elements
     graphBuilderState.setMessage(`Building other elements...`);
     await this.buildFileGenerations(graph, inputs, options);
@@ -995,6 +1022,31 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         ),
       ),
     );
+    // Fourth Pass
+    await Promise.all(
+      inputs.flatMap((input) =>
+        input.data.classes.map((element) =>
+          this.visitWithGraphBuilderErrorHandling(
+            element,
+            new V1_ProtocolToMetaModelGraphFourthPassBuilder(
+              this.getBuilderContext(graph, input.model, element, options),
+            ),
+          ),
+        ),
+      ),
+    );
+    await Promise.all(
+      inputs.flatMap((input) =>
+        input.data.associations.map((element) =>
+          this.visitWithGraphBuilderErrorHandling(
+            element,
+            new V1_ProtocolToMetaModelGraphFourthPassBuilder(
+              this.getBuilderContext(graph, input.model, element, options),
+            ),
+          ),
+        ),
+      ),
+    );
     // Fifth pass
     await Promise.all(
       inputs.flatMap((input) =>
@@ -1159,6 +1211,25 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     );
   }
 
+  private async buildDataElements(
+    graph: PureModel,
+    inputs: V1_GraphBuilderInput[],
+    options?: GraphBuilderOptions,
+  ): Promise<void> {
+    await Promise.all(
+      inputs.flatMap((input) =>
+        input.data.dataElements.map((element) =>
+          this.visitWithGraphBuilderErrorHandling(
+            element,
+            new V1_ProtocolToMetaModelGraphSecondPassBuilder(
+              this.getBuilderContext(graph, input.model, element, options),
+            ),
+          ),
+        ),
+      ),
+    );
+  }
+
   private async buildFileGenerations(
     graph: PureModel,
     inputs: V1_GraphBuilderInput[],
@@ -1555,6 +1626,50 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     return this.pureModelContextDataToEntities(generatedModel);
   }
 
+  // ------------------------------------------- Test  -------------------------------------------
+
+  async runTests(
+    inputs: RunTestsTestableInput[],
+    graph: PureModel,
+  ): Promise<TestResult[]> {
+    const runTestsInput = new V1_RunTestsInput();
+    runTestsInput.model = this.getFullGraphModelData(graph);
+    runTestsInput.testables = inputs
+      .map((input) => {
+        const testable = guaranteeNonNullable(
+          getNullableIDFromTestable(
+            input.testable,
+            graph,
+            this.pluginManager.getPureGraphManagerPlugins(),
+          ),
+        );
+        if (!testable) {
+          return undefined;
+        }
+        const runTestableInput = new V1_RunTestsTestableInput();
+        runTestableInput.testable = testable;
+        runTestableInput.unitTestIds = input.unitTestIds.map((unit) => {
+          const unitAtomicTest = new V1_AtomicTestId();
+          unitAtomicTest.testSuiteId = unit.parentSuite?.id;
+          unitAtomicTest.atomicTestId = unit.atomicTest.id;
+          return unitAtomicTest;
+        });
+        return runTestableInput;
+      })
+      .filter(isNonNullable);
+    const runTestsResult = await this.engine.runTests(runTestsInput);
+    const result = V1_buildTestsResult(
+      runTestsResult,
+      (id: string): Testable | undefined =>
+        getNullableTestable(
+          id,
+          graph,
+          this.pluginManager.getPureGraphManagerPlugins(),
+        ),
+    );
+    return result;
+  }
+
   // ------------------------------------------- ValueSpecification -------------------------------------------
 
   buildValueSpecification(
@@ -1699,6 +1814,23 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     lambda: RawLambda,
     runtime: Runtime,
     clientVersion: string,
+  ): V1_ExecuteInput =>
+    this.buildExecutionInput(
+      graph,
+      mapping,
+      lambda,
+      runtime,
+      clientVersion,
+      new V1_ExecuteInput(),
+    );
+
+  private buildExecutionInput = (
+    graph: PureModel,
+    mapping: Mapping,
+    lambda: RawLambda,
+    runtime: Runtime,
+    clientVersion: string,
+    executeInput: V1_ExecuteInput,
   ): V1_ExecuteInput => {
     /**
      * NOTE: to lessen network load, we might need to think of a way to only include relevant part of the pure model context data here
@@ -1737,7 +1869,6 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
       .concat(extraExecutionElements);
     // NOTE: for execution, we usually will just assume that we send the connections embedded in the runtime value, since we don't want the user to have to create
     // packageable runtime and connection just to play with execution.
-    const executeInput = new V1_ExecuteInput();
     executeInput.clientVersion = clientVersion;
     executeInput.function = V1_transformRawLambda(
       lambda,
@@ -1785,10 +1916,26 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     lambda: RawLambda,
     runtime: Runtime,
     clientVersion: string,
+    parameters: (string | number | boolean)[],
+    options?: {
+      anonymizeGeneratedData?: boolean;
+    },
   ): Promise<string> {
-    return this.engine.generateMappingTestData(
-      this.createExecutionInput(graph, mapping, lambda, runtime, clientVersion),
+    const testDataGenerationExecuteInput =
+      new V1_TestDataGenerationExecutionInput();
+    this.buildExecutionInput(
+      graph,
+      mapping,
+      lambda,
+      runtime,
+      clientVersion,
+      testDataGenerationExecuteInput,
     );
+    testDataGenerationExecuteInput.parameters = parameters;
+    testDataGenerationExecuteInput.hashStrings = Boolean(
+      options?.anonymizeGeneratedData,
+    );
+    return this.engine.generateMappingTestData(testDataGenerationExecuteInput);
   }
 
   generateExecutionPlan(
@@ -1862,10 +2009,10 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
 
   // --------------------------------------------- Service ---------------------------------------------
 
-  async runServiceTests(
+  async runLegacyServiceTests(
     service: Service,
     graph: PureModel,
-  ): Promise<ServiceTestResult[]> {
+  ): Promise<DEPRECATED__ServiceTestResult[]> {
     const protocolGraph = this.getFullGraphModelData(graph);
     const targetService = guaranteeNonNullable(
       protocolGraph.elements
@@ -1877,8 +2024,8 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
       (element) => !(element instanceof V1_Service),
     );
     protocolGraph.elements.push(targetService);
-    return (await this.engine.runServiceTests(protocolGraph)).map(
-      V1_buildServiceTestResult,
+    return (await this.engine.runLegacyServiceTests(protocolGraph)).map(
+      V1_buildLegacyServiceTestResult,
     );
   }
 
@@ -1919,7 +2066,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         if (execution instanceof PureSingleExecution) {
           sdlcInfo.packageableElementPointers = [
             new V1_PackageableElementPointer(
-              V1_PackageableElementPointerType.MAPPING,
+              PackageableElementPointerType.MAPPING,
               execution.mapping.value.path,
             ),
           ];
@@ -1928,7 +2075,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
             execution.executionParameters.map(
               (e) =>
                 new V1_PackageableElementPointer(
-                  V1_PackageableElementPointerType.MAPPING,
+                  PackageableElementPointerType.MAPPING,
                   e.mapping.value.path,
                 ),
             );
@@ -1947,7 +2094,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         const pointer = new V1_PureModelContextPointer(protocol, sdlcInfo);
         sdlcInfo.packageableElementPointers = [
           new V1_PackageableElementPointer(
-            V1_PackageableElementPointerType.SERVICE,
+            PackageableElementPointerType.SERVICE,
             service.path,
           ),
         ];
@@ -2112,16 +2259,18 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
       v1Mappings.forEach((element) => {
         const mapping = mappings.find((e) => e.path === element.path);
         if (mapping) {
-          mapping.includes = element.includedMappings.map((i) => {
-            assertNonEmptyString(
-              i.includedMappingPath,
-              `Mapping include 'includedMappingPath' field is missing or empty`,
-            );
-            return new MappingInclude(
-              mapping,
-              context.resolveMapping(i.includedMappingPath),
-            );
-          });
+          mapping.includes = element.includedMappings.map(
+            (i) =>
+              new MappingInclude(
+                mapping,
+                context.resolveMapping(
+                  guaranteeNonEmptyString(
+                    V1_getIncludedMappingPath(i),
+                    `Mapping include path is missing or empty`,
+                  ),
+                ),
+              ),
+          );
         }
       });
       // handle runtimes
@@ -2142,10 +2291,8 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
           );
         }
       });
-      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
@@ -2188,7 +2335,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
           if (serviceExecution instanceof V1_PureMultiExecution) {
             const execution = new PureMultiExecution(
               serviceExecution.executionKey,
-              RawLambda.createStub(),
+              stub_RawLambda(),
               service,
             );
             execution.executionParameters =
@@ -2203,7 +2350,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
             service.execution = execution;
           } else if (serviceExecution instanceof V1_PureSingleExecution) {
             service.execution = new PureSingleExecution(
-              RawLambda.createStub(),
+              stub_RawLambda(),
               service,
               PackageableElementExplicitReference.create(new Mapping('')),
               new EngineRuntime(),
@@ -2211,10 +2358,8 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
           }
         }
       });
-      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
@@ -2442,6 +2587,8 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
       return CORE_PURE_PATH.SERVICE;
     } else if (protocol instanceof V1_FileGenerationSpecification) {
       return CORE_PURE_PATH.FILE_GENERATION;
+    } else if (protocol instanceof V1_DataElement) {
+      return CORE_PURE_PATH.DATA_ELEMENT;
     } else if (protocol instanceof V1_GenerationSpecification) {
       return CORE_PURE_PATH.GENERATION_SPECIFICATION;
     }