@finos/legend-graph 4.0.3 → 6.0.1

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

@@ -15,7 +15,7 @@
  */
 import { GRAPH_MANAGER_EVENT } from '../../../../graphManager/GraphManagerEvent';
 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 { TracerService, LogEvent, getClass, guaranteeNonNullable, UnsupportedOperationError, recursiveOmit, assertTrue, assertErrorThrown, promisify, StopWatch, assertNonEmptyString, filterByType, } from '@finos/legend-shared';
 import { AbstractPureGraphManager, } from '../../../../graphManager/AbstractPureGraphManager';
 import { Mapping } from '../../../metamodels/pure/packageableElements/mapping/Mapping';
 import { EngineRuntime, } from '../../../metamodels/pure/packageableElements/runtime/Runtime';
@@ -26,7 +26,7 @@ import { KeyedExecutionParameter, PureMultiExecution, PureSingleExecution, } fro
 import { V1_deserializeRawValueSpecification, V1_serializeRawValueSpecification, } from './transformation/pureProtocol/serializationHelpers/V1_RawValueSpecificationSerializationHelper';
 import { V1_serializeValueSpecification, V1_deserializeValueSpecification, } from './transformation/pureProtocol/serializationHelpers/V1_ValueSpecificationSerializer';
 import V1_CORE_SYSTEM_MODELS from './V1_Core_SystemModels.json';
-import { V1_PackageableElementSerializer } from './transformation/pureProtocol/V1_PackageableElementSerialization';
+import { V1_serializePackageableElement } from './transformation/pureProtocol/V1_PackageableElementSerialization';
 import { V1_entitiesToPureModelContextData, V1_serializePureModelContext, V1_deserializePureModelContextData, V1_setupPureModelContextDataSerialization, } from './transformation/pureProtocol/V1_PureProtocolSerialization';
 import { V1_PureModelContextData } from './model/context/V1_PureModelContextData';
 import { V1_PackageableElementPointerType, V1_PackageableElementPointer, } from './model/packageableElements/V1_PackageableElement';
@@ -40,10 +40,10 @@ import { V1_RawBaseExecutionContext } from './model/rawValueSpecification/V1_Raw
 import { V1_GraphBuilderContextBuilder, } from './transformation/pureGraph/to/V1_GraphBuilderContext';
 import { V1_PureModelContextPointer } from './model/context/V1_PureModelContextPointer';
 import { V1_Engine } from './engine/V1_Engine';
-import { V1_PackageableElementTransformer } from './transformation/pureGraph/from/V1_PackageableElementTransformer';
+import { V1_transformPackageableElement } from './transformation/pureGraph/from/V1_PackageableElementTransformer';
 import { V1_transformRawLambda, V1_RawValueSpecificationTransformer, } from './transformation/pureGraph/from/V1_RawValueSpecificationTransformer';
 import { V1_transformRuntime } from './transformation/pureGraph/from/V1_RuntimeTransformer';
-import { V1_ExecuteInput } from './engine/execution/V1_ExecuteInput';
+import { V1_ExecuteInput, V1_TestDataGenerationExecutionInput, } from './engine/execution/V1_ExecuteInput';
 import { V1_buildValueSpecification } from './transformation/pureGraph/to/helpers/V1_ValueSpecificationBuilderHelper';
 import { V1_transformRootValueSpecification } from './transformation/pureGraph/from/V1_ValueSpecificationTransformer';
 import { V1_Profile } from './model/packageableElements/domain/V1_Profile';
@@ -85,6 +85,7 @@ import { V1_PureMultiExecution, V1_PureSingleExecution, } from './model/packagea
 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';
+import { V1_DataElement } from './model/packageableElements/data/V1_DataElement';
 const V1_FUNCTION_SUFFIX_MULTIPLICITY_INFINITE = 'MANY';
 const getMultiplicitySuffix = (multiplicity) => {
     if (multiplicity.lowerBound === multiplicity.upperBound) {
@@ -119,6 +120,7 @@ class V1_PureModelContextDataIndex {
     services = [];
     fileGenerations = [];
     generationSpecifications = [];
+    dataElements = [];
     otherElementsByBuilder = new Map();
 }
 const mergePureModelContextData = (...data) => {
@@ -178,6 +180,9 @@ const indexPureModelContextData = (report, data, extensions) => {
         else if (el instanceof V1_GenerationSpecification) {
             index.generationSpecifications.push(el);
         }
+        else if (el instanceof V1_DataElement) {
+            index.dataElements.push(el);
+        }
         else {
             const clazz = getClass(el);
             if (otherElementsByClass.has(clazz)) {
@@ -289,7 +294,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         catch (error) {
             assertErrorThrown(error);
             graphBuilderState.fail();
-            this.log.error(LogEvent.create(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_FAILURE));
+            this.log.error(LogEvent.create(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_FAILURE), error);
             throw new SystemGraphBuilderError(error);
         }
         finally {
@@ -317,8 +322,8 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
             stopWatch.record(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_ELEMENTS_DESERIALIZED);
             // prepare build inputs
             const buildInputs = Array.from(dependencyDataMap.entries()).map(([dependencyKey, dependencyData]) => ({
-                data: indexPureModelContextData(report, dependencyData, this.extensions),
                 model: graph.dependencyManager.getModel(dependencyKey),
+                data: indexPureModelContextData(report, dependencyData, this.extensions),
             }));
             // build
             await this.buildGraphFromInputs(graph, buildInputs, report, stopWatch, graphBuilderState, options);
@@ -332,7 +337,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         }
         catch (error) {
             assertErrorThrown(error);
-            this.log.error(LogEvent.create(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_FAILURE));
+            this.log.error(LogEvent.create(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_FAILURE), error);
             graphBuilderState.fail();
             throw new DependencyGraphBuilderError(error);
         }
@@ -365,7 +370,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
              * 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) {
+            if (!options?.TEMPORARY__preserveSectionIndex) {
                 graph.TEMPORARY__deleteOwnSectionIndex();
             }
             graphBuilderState.pass();
@@ -377,7 +382,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         }
         catch (error) {
             assertErrorThrown(error);
-            this.log.error(LogEvent.create(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_FAILURE));
+            this.log.error(LogEvent.create(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_FAILURE), error);
             graphBuilderState.fail();
             /**
              * Wrap all error with `GraphBuilderError`, as we throw a lot of assertion error in the graph builder
@@ -409,9 +414,8 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
             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,
+                data: indexPureModelContextData(report, generatedData, this.extensions),
             }));
             // build
             await this.buildGraphFromInputs(graph, buildInputs, report, stopWatch, graphBuilderState, options);
@@ -425,7 +429,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         }
         catch (error) {
             assertErrorThrown(error);
-            this.log.error(LogEvent.create(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_FAILURE));
+            this.log.error(LogEvent.create(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_FAILURE), error);
             graphBuilderState.fail();
             /**
              * Wrap all error with `GraphBuilderError`, as we throw a lot of assertion error in the graph builder
@@ -468,6 +472,10 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         graphBuilderState.setMessage(`Building services...`);
         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);
@@ -489,68 +497,82 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
      * NOTE: We aim to not do anything more than running the first pass and indexing the first pass.
      */
     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))))));
+        // create the element path cache for faster duplication check
+        // NOTE: We base on the assumption here that our graph building is cascading, i.e.
+        // it first builds core, system, dependencies, graph, and generation.
+        // this way, as we build the a graph, we know the next step's duplication check
+        // has path cache consisting of all element from its base graphs
+        const elementPathCache = new Set(graph.allElements.map((el) => el.path));
+        await Promise.all(inputs.flatMap(async (input) => {
+            // create the package cache
+            const packageCache = new Map();
+            await Promise.all(input.data.nativeElements.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphFirstPassBuilder(this.getBuilderContext(graph, input.model, element, options), packageCache, elementPathCache))));
+            await Promise.all(this.extensions.sortedExtraElementBuilders.flatMap(async (builder) => (input.data.otherElementsByBuilder.get(builder) ?? []).map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphFirstPassBuilder(this.getBuilderContext(graph, input.model, element, options), packageCache, elementPathCache)))));
         }));
     }
     async buildTypes(graph, inputs, options) {
         // Second pass
-        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))))));
+        await Promise.all(inputs.flatMap((input) => input.data.profiles.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        await Promise.all(inputs.flatMap((input) => input.data.classes.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        await Promise.all(inputs.flatMap((input) => input.data.enumerations.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        await Promise.all(inputs.flatMap((input) => input.data.measures.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        await Promise.all(inputs.flatMap((input) => input.data.functions.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
         // Third pass
-        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))))));
+        await Promise.all(inputs.flatMap((input) => input.data.classes.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphThirdPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        await Promise.all(inputs.flatMap((input) => input.data.associations.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphThirdPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        // 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) => 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.visitWithGraphBuilderErrorHandling(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))))));
+        await Promise.all(inputs.flatMap((input) => input.data.stores.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        await Promise.all(inputs.flatMap((input) => input.data.stores.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphThirdPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        await Promise.all(inputs.flatMap((input) => input.data.stores.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphFourthPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        await Promise.all(inputs.flatMap((input) => input.data.stores.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphFifthPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
     }
     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))))));
+        await Promise.all(inputs.flatMap((input) => input.data.mappings.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        await Promise.all(inputs.flatMap((input) => input.data.mappings.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphThirdPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        await Promise.all(inputs.flatMap((input) => input.data.mappings.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphFourthPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
     }
     async buildConnectionsAndRuntimes(graph, inputs, options) {
         // NOTE: connections must be built before runtimes
-        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))))));
+        await Promise.all(inputs.flatMap((input) => input.data.connections.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+        await Promise.all(inputs.flatMap((input) => input.data.runtimes.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
     }
     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))))));
+        await Promise.all(inputs.flatMap((input) => input.data.services.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+    }
+    async buildDataElements(graph, inputs, options) {
+        await Promise.all(inputs.flatMap((input) => input.data.dataElements.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
     }
     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))))));
+        await Promise.all(inputs.flatMap((input) => input.data.fileGenerations.map((element) => this.visitWithGraphBuilderErrorHandling(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))))));
+        await Promise.all(inputs.flatMap((input) => input.data.generationSpecifications.map((element) => this.visitWithGraphBuilderErrorHandling(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))))));
+        await Promise.all(inputs.flatMap((input) => input.data.sectionIndices.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
     }
     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))))));
-            await Promise.all(inputs.flatMap((input) => (input.data.otherElementsByBuilder.get(builder) ?? []).map((element) => this.visitWithErrorHandling(element, new V1_ProtocolToMetaModelGraphFifthPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+            await Promise.all(inputs.flatMap((input) => (input.data.otherElementsByBuilder.get(builder) ?? []).map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+            await Promise.all(inputs.flatMap((input) => (input.data.otherElementsByBuilder.get(builder) ?? []).map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphThirdPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+            await Promise.all(inputs.flatMap((input) => (input.data.otherElementsByBuilder.get(builder) ?? []).map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphFourthPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
+            await Promise.all(inputs.flatMap((input) => (input.data.otherElementsByBuilder.get(builder) ?? []).map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ProtocolToMetaModelGraphFifthPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
         }));
     }
-    visitWithErrorHandling(element, visitor) {
+    visitWithGraphBuilderErrorHandling(element, visitor) {
         try {
             return promisify(() => element.accept_PackageableElementVisitor(visitor));
         }
         catch (err) {
             assertErrorThrown(err);
             const error = err instanceof GraphBuilderError ? err : new GraphBuilderError(err);
-            error.message = `Error processing element '${element.path}': ${err.message}`;
+            error.message = `Can't build element '${element.path}': ${err.message}`;
             throw error;
         }
     }
@@ -717,7 +739,8 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         return this.pureModelContextDataToEntities(graphData);
     };
     // --------------------------------------------- Execution ---------------------------------------------
-    createExecutionInput = (graph, mapping, lambda, runtime, clientVersion) => {
+    createExecutionInput = (graph, mapping, lambda, runtime, clientVersion) => this.buildExecutionInput(graph, mapping, lambda, runtime, clientVersion, new V1_ExecuteInput());
+    buildExecutionInput = (graph, mapping, lambda, runtime, clientVersion, 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
          *
@@ -752,7 +775,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, new V1_GraphTransformerContextBuilder(this.pluginManager.getPureProtocolProcessorPlugins()).build());
         executeInput.mapping = mapping.path;
@@ -764,8 +786,12 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     async executeMapping(graph, mapping, lambda, runtime, clientVersion, options) {
         return V1_buildExecutionResult(await this.engine.executeMapping(this.createExecutionInput(graph, mapping, lambda, runtime, clientVersion), options));
     }
-    generateMappingTestData(graph, mapping, lambda, runtime, clientVersion) {
-        return this.engine.generateMappingTestData(this.createExecutionInput(graph, mapping, lambda, runtime, clientVersion));
+    generateMappingTestData(graph, mapping, lambda, runtime, clientVersion, parameters, options) {
+        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(graph, mapping, lambda, runtime, clientVersion) {
         return this.engine.generateExecutionPlan(this.createExecutionInput(graph, mapping, lambda, runtime, clientVersion));
@@ -790,7 +816,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     async runServiceTests(service, graph) {
         const protocolGraph = this.getFullGraphModelData(graph);
         const targetService = guaranteeNonNullable(protocolGraph.elements
-            .filter((element) => element instanceof V1_Service)
+            .filter(filterByType(V1_Service))
             .find((element) => element.path === service.path), `Can't run service test: service '${service.path}' not found`);
         protocolGraph.elements = protocolGraph.elements.filter((element) => !(element instanceof V1_Service));
         protocolGraph.elements.push(targetService);
@@ -921,7 +947,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
                 ...graph.dependencyManager.mappings,
             ];
             const v1Mappings = graphBuilderInput
-                .map((e) => e.data.elements.filter((type) => type instanceof V1_Mapping))
+                .map((e) => e.data.elements.filter(filterByType(V1_Mapping)))
                 .flat();
             const context = new V1_GraphBuilderContextBuilder(graph, graph, this.extensions, this.log).build();
             // build include index for compatible runtime analysis
@@ -940,7 +966,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
                 ...graph.dependencyManager.runtimes,
             ];
             const v1Runtimes = graphBuilderInput
-                .map((e) => e.data.elements.filter((type) => type instanceof V1_PackageableRuntime))
+                .map((e) => e.data.elements.filter(filterByType(V1_PackageableRuntime)))
                 .flat();
             v1Runtimes.forEach((element) => {
                 const runtime = runtimes.find((e) => e.path === element.path);
@@ -976,7 +1002,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
                 ...graph.dependencyManager.services,
             ];
             const v1Services = graphBuilderInput
-                .map((e) => e.data.elements.filter((type) => type instanceof V1_Service))
+                .map((e) => e.data.elements.filter(filterByType(V1_Service)))
                 .flat();
             // build service multi execution keys
             v1Services.forEach((element) => {
@@ -1087,13 +1113,13 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         ];
         return contextData1;
     }
-    elementToProtocol = (element, options) => element.accept_PackageableElementVisitor(new V1_PackageableElementTransformer(this.pluginManager.getPureProtocolProcessorPlugins(), new V1_GraphTransformerContextBuilder(this.pluginManager.getPureProtocolProcessorPlugins())
+    elementToProtocol = (element, options) => V1_transformPackageableElement(element, this.pluginManager.getPureProtocolProcessorPlugins(), new V1_GraphTransformerContextBuilder(this.pluginManager.getPureProtocolProcessorPlugins())
         .withKeepSourceInformationFlag(Boolean(options?.keepSourceInformation))
-        .build()));
+        .build());
     pureModelContextDataToEntities = (graphProtocol) => graphProtocol.elements.map((element) => this.elementProtocolToEntity(element));
     elementProtocolToEntity = (elementProtocol) => ({
         path: this.getElementPath(elementProtocol),
-        content: elementProtocol.accept_PackageableElementVisitor(new V1_PackageableElementSerializer(this.pluginManager.getPureProtocolProcessorPlugins())),
+        content: V1_serializePackageableElement(elementProtocol, this.pluginManager.getPureProtocolProcessorPlugins()),
         classifierPath: this.getElementClassiferPath(elementProtocol),
     });
     getElementPath = (elementProtocol) => {
@@ -1153,6 +1179,9 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         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;
         }
@@ -1182,7 +1211,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         const dependencyManager = graph.dependencyManager;
         const generatedModel = graph.generationModel;
         graphData.elements = [
-            ...dependencyManager.allElements,
+            ...dependencyManager.allOwnElements,
             ...generatedModel.allOwnElements,
         ].map((element) => this.elementToProtocol(element));
         this.log.info(LogEvent.create(GRAPH_MANAGER_EVENT.GRAPH_COMPILE_CONTEXT_COLLECTED), Date.now() - startTime, 'ms');
@@ -1213,7 +1242,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         return this.pureModelContextDataToEntities(await this.engine.buildDatabase(dbBuilderInput));
     }
     // --------------------------------------------- HACKY ---------------------------------------------
-    HACKY_createGetAllLambda(_class) {
+    HACKY__createGetAllLambda(_class) {
         return new RawLambda([], [
             {
                 _type: 'func',
@@ -1227,7 +1256,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
             },
         ]);
     }
-    HACKY_createServiceTestAssertLambda(assertData) {
+    HACKY__createServiceTestAssertLambda(assertData) {
         return new RawLambda([
             {
                 _type: 'var',
@@ -1274,7 +1303,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
             },
         ]);
     }
-    HACKY_extractServiceTestAssertionData(query) {
+    HACKY__extractServiceTestAssertionData(query) {
         let json;
         try {
             json = query.body[0] // FunctionValue
@@ -1291,5 +1320,14 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
         }
         return json;
     }
+    HACKY__createDefaultBlankLambda() {
+        return new RawLambda([{ _type: 'var', name: 'x' }], [
+            {
+                _type: 'string',
+                multiplicity: { lowerBound: 1, upperBound: 1 },
+                values: [''],
+            },
+        ]);
+    }
 }
 //# sourceMappingURL=V1_PureGraphManager.js.map