@finos/legend-graph 27.0.3 → 28.0.0

package/lib/graphManager/protocol/pure/v1/V1_PureGraphManager.js

@@ -1,1649 +0,0 @@
-/**
- * Copyright (c) 2020-present, Goldman Sachs
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import { GRAPH_MANAGER_EVENT } from '../../../../graphManager/GraphManagerEvent.js';
-import { CORE_PURE_PATH, PackageableElementPointerType, } from '../../../../graph/MetaModelConst.js';
-import { ActionState, TracerService, LogEvent, getClass, guaranteeNonNullable, UnsupportedOperationError, assertErrorThrown, promisify, StopWatch, isNonNullable, addUniqueEntry, uuid, deleteEntry, uniq, IllegalStateError, filterByType, getNullableFirstElement, } from '@finos/legend-shared';
-import { AbstractPureGraphManager, } from '../../../../graphManager/AbstractPureGraphManager.js';
-import { PureModel, } from '../../../../graph/PureModel.js';
-import { RawLambda } from '../../../../graph/metamodel/pure/rawValueSpecification/RawLambda.js';
-import { ServiceRegistrationSuccess, ServiceRegistrationFail, } from '../../../../graphManager/action/service/ServiceRegistrationResult.js';
-import { ServiceExecutionMode } from '../../../../graphManager/action/service/ServiceExecutionMode.js';
-import { PureMultiExecution, PureSingleExecution, } from '../../../../graph/metamodel/pure/packageableElements/service/ServiceExecution.js';
-import { V1_deserializeRawValueSpecification, V1_serializeRawValueSpecification, } from './transformation/pureProtocol/serializationHelpers/V1_RawValueSpecificationSerializationHelper.js';
-import { V1_serializeValueSpecification, V1_deserializeValueSpecification, } from './transformation/pureProtocol/serializationHelpers/V1_ValueSpecificationSerializer.js';
-import V1_CORE_SYSTEM_MODELS from './V1_Core_SystemModels.json';
-import { V1_serializePackageableElement } from './transformation/pureProtocol/V1_PackageableElementSerialization.js';
-import { V1_entitiesToPureModelContextData, V1_serializePureModelContext, V1_deserializePureModelContextData, V1_setupPureModelContextDataSerialization, } from './transformation/pureProtocol/V1_PureProtocolSerialization.js';
-import { V1_PureModelContextData } from './model/context/V1_PureModelContextData.js';
-import { V1_PackageableElementPointer, } from './model/packageableElements/V1_PackageableElement.js';
-import { V1_ElementFirstPassBuilder } from './transformation/pureGraph/to/V1_ElementFirstPassBuilder.js';
-import { V1_ElementSecondPassBuilder } from './transformation/pureGraph/to/V1_ElementSecondPassBuilder.js';
-import { V1_ElementThirdPassBuilder } from './transformation/pureGraph/to/V1_ElementThirdPassBuilder.js';
-import { V1_ElementFourthPassBuilder } from './transformation/pureGraph/to/V1_ElementFourthPassBuilder.js';
-import { V1_ElementFifthPassBuilder } from './transformation/pureGraph/to/V1_ElementFifthPassBuilder.js';
-import { V1_RawValueSpecificationBuilder } from './transformation/pureGraph/to/V1_RawValueSpecificationBuilder.js';
-import { V1_RawBaseExecutionContext } from './model/rawValueSpecification/V1_RawExecutionContext.js';
-import { V1_GraphBuilderContextBuilder, V1_buildFullPath, } from './transformation/pureGraph/to/V1_GraphBuilderContext.js';
-import { V1_PureModelContextPointer } from './model/context/V1_PureModelContextPointer.js';
-import { V1_Engine } from './engine/V1_Engine.js';
-import { V1_transformPackageableElement } from './transformation/pureGraph/from/V1_PackageableElementTransformer.js';
-import { V1_transformRawLambda, V1_RawValueSpecificationTransformer, } from './transformation/pureGraph/from/V1_RawValueSpecificationTransformer.js';
-import { V1_transformRuntime } from './transformation/pureGraph/from/V1_RuntimeTransformer.js';
-import { V1_ExecuteInput, V1_TestDataGenerationExecutionInput, } from './engine/execution/V1_ExecuteInput.js';
-import { V1_buildValueSpecification } from './transformation/pureGraph/to/helpers/V1_ValueSpecificationBuilderHelper.js';
-import { V1_transformRootValueSpecification } from './transformation/pureGraph/from/V1_ValueSpecificationTransformer.js';
-import { V1_Profile } from './model/packageableElements/domain/V1_Profile.js';
-import { V1_Class } from './model/packageableElements/domain/V1_Class.js';
-import { V1_Enumeration } from './model/packageableElements/domain/V1_Enumeration.js';
-import { V1_Association } from './model/packageableElements/domain/V1_Association.js';
-import { V1_Measure } from './model/packageableElements/domain/V1_Measure.js';
-import { V1_Store } from './model/packageableElements/store/V1_Store.js';
-import { V1_Service } from './model/packageableElements/service/V1_Service.js';
-import { V1_PackageableRuntime } from './model/packageableElements/runtime/V1_PackageableRuntime.js';
-import { V1_PackageableConnection } from './model/packageableElements/connection/V1_PackageableConnection.js';
-import { V1_FileGenerationSpecification } from './model/packageableElements/fileGeneration/V1_FileGenerationSpecification.js';
-import { V1_SectionIndex } from './model/packageableElements/section/V1_SectionIndex.js';
-import { V1_GenerationSpecification } from './model/packageableElements/generationSpecification/V1_GenerationSpecification.js';
-import { V1_Mapping } from './model/packageableElements/mapping/V1_Mapping.js';
-import { V1_ConcreteFunctionDefinition } from './model/packageableElements/function/V1_ConcreteFunctionDefinition.js';
-import { V1_PureModelContextComposite } from './model/context/V1_PureModelContextComposite.js';
-import { V1_LegendSDLC } from './model/context/V1_SDLC.js';
-import { V1_Protocol } from './model/V1_Protocol.js';
-import { V1_GraphBuilderExtensions } from './transformation/pureGraph/to/V1_GraphBuilderExtensions.js';
-import { V1_DatabaseBuilderConfig, V1_DatabaseBuilderInput, V1_DatabasePattern, V1_setupDatabaseBuilderInputSerialization, V1_TargetDatabase, } from './engine/generation/V1_DatabaseBuilderInput.js';
-import { V1_transformRelationalDatabaseConnection } from './transformation/pureGraph/from/V1_ConnectionTransformer.js';
-import { V1_FlatData } from './model/packageableElements/store/flatData/model/V1_FlatData.js';
-import { V1_Database } from './model/packageableElements/store/relational/model/V1_Database.js';
-import { V1_setupDatabaseSerialization } from './transformation/pureProtocol/serializationHelpers/V1_DatabaseSerializationHelper.js';
-import { V1_setupEngineRuntimeSerialization, V1_setupLegacyRuntimeSerialization, } from './transformation/pureProtocol/serializationHelpers/V1_RuntimeSerializationHelper.js';
-import { V1_GraphTransformerContextBuilder } from './transformation/pureGraph/from/V1_GraphTransformerContext.js';
-import { V1_transformExecutionNode, V1_transformExecutionPlan, } from './transformation/pureGraph/from/executionPlan/V1_ExecutionPlanTransformer.js';
-import { V1_deserializeExecutionPlan, V1_serializeExecutionNode, V1_serializeExecutionPlan, } from './transformation/pureProtocol/serializationHelpers/executionPlan/V1_ExecutionPlanSerializationHelper.js';
-import { V1_buildExecutionPlan } from './transformation/pureGraph/to/V1_ExecutionPlanBuilder.js';
-import { V1_buildQuery, V1_buildServiceRegistrationSuccess, V1_transformQuery, V1_buildGenerationOutput, V1_buildLightQuery, V1_transformQuerySearchSpecification, } from './engine/V1_EngineHelper.js';
-import { V1_buildExecutionResult } from './engine/execution/V1_ExecutionHelper.js';
-import { ENTITY_PATH_DELIMITER, } from '@finos/legend-storage';
-import { DependencyGraphBuilderError, GraphBuilderError, PureClientVersion, SystemGraphBuilderError, } from '../../../../graphManager/GraphManagerUtils.js';
-import { PackageableElementReference } from '../../../../graph/metamodel/pure/packageableElements/PackageableElementReference.js';
-import { V1_ExternalFormatModelGenerationInput } from './engine/externalFormat/V1_ExternalFormatModelGeneration.js';
-import { V1_GenerateSchemaInput } from './engine/externalFormat/V1_GenerateSchemaInput.js';
-import { createGraphBuilderReport, createGraphManagerOperationReport, } from '../../../GraphManagerStatistics.js';
-import { V1_DataElement } from './model/packageableElements/data/V1_DataElement.js';
-import { V1_RunTestsInput, V1_RunTestsTestableInput, } from './engine/test/V1_RunTestsInput.js';
-import { V1_UniqueTestId } from './model/test/V1_UniqueTestId.js';
-import { V1_buildTestsResult } from './engine/test/V1_RunTestsResult.js';
-import { TestError, TestExecuted, TestExecutionStatus, } from '../../../../graph/metamodel/pure/test/result/TestResult.js';
-import { getNullableIDFromTestable, getNullableTestable, } from '../../../helpers/DSL_Data_GraphManagerHelper.js';
-import { AssertFail } from '../../../../graph/metamodel/pure/test/assertion/status/AssertFail.js';
-import { TestSuite, } from '../../../../graph/metamodel/pure/test/Test.js';
-import { pruneSourceInformation } from '../../../../graph/MetaModelUtils.js';
-import { V1_buildModelCoverageAnalysisResult, V1_MappingModelCoverageAnalysisInput, V1_MappingModelCoverageAnalysisResult, } from './engine/analytics/V1_MappingModelCoverageAnalysis.js';
-import { deserialize } from 'serializr';
-import { SchemaSet } from '../../../../graph/metamodel/pure/packageableElements/externalFormat/schemaSet/DSL_ExternalFormat_SchemaSet.js';
-import { CompilationWarning } from '../../../action/compilation/CompilationWarning.js';
-import { V1_transformParameterValue } from './transformation/pureGraph/from/V1_ServiceTransformer.js';
-import { V1_transformModelUnit } from './transformation/pureGraph/from/V1_DSL_ExternalFormat_Transformer.js';
-import { V1_LambdaReturnTypeInput } from './engine/compilation/V1_LambdaReturnType.js';
-import { MultiExecutionServiceTestResult } from '../../../../graph/metamodel/pure/packageableElements/service/MultiExecutionServiceTestResult.js';
-import { V1_ExecutionEnvironmentInstance } from './model/packageableElements/service/V1_ExecutionEnvironmentInstance.js';
-import { V1_StoreEntitlementAnalysisInput, V1_buildDatasetEntitlementReport, V1_buildDatasetSpecification, } from './engine/analytics/V1_StoreEntitlementAnalysis.js';
-import { LegendSDLC, } from '../../../../graph/GraphDataOrigin.js';
-import { LiveGraphData, GraphDataWithOrigin, } from '../../../GraphData.js';
-import { DEPRECATED__validate_MappingTest } from '../../../action/validation/DSL_Mapping_ValidationHelper.js';
-class V1_PureModelContextDataIndex {
-    elements = [];
-    nativeElements = [];
-    associations = [];
-    classes = [];
-    enumerations = [];
-    functions = [];
-    profiles = [];
-    measures = [];
-    stores = [];
-    mappings = [];
-    connections = [];
-    runtimes = [];
-    sectionIndices = [];
-    services = [];
-    fileGenerations = [];
-    generationSpecifications = [];
-    dataElements = [];
-    executionEnvironments = [];
-    otherElementsByBuilder = new Map();
-}
-const mergePureModelContextData = (...data) => {
-    const mergedData = new V1_PureModelContextData();
-    for (const _data of data) {
-        mergedData.elements = mergedData.elements.concat(_data.elements);
-        mergedData.serializer = _data.serializer ?? mergedData.serializer;
-        mergedData.origin = _data.origin ?? mergedData.origin;
-    }
-    return mergedData;
-};
-export const V1_indexPureModelContextData = (report, data, extensions) => {
-    const index = new V1_PureModelContextDataIndex();
-    index.elements = data.elements;
-    const otherElementsByClass = new Map();
-    data.elements.forEach((el) => {
-        let isIndexedAsOtherElement = false;
-        if (el instanceof V1_Association) {
-            index.associations.push(el);
-        }
-        else if (el instanceof V1_Class) {
-            index.classes.push(el);
-        }
-        else if (el instanceof V1_Enumeration) {
-            index.enumerations.push(el);
-        }
-        else if (el instanceof V1_ConcreteFunctionDefinition) {
-            index.functions.push(el);
-        }
-        else if (el instanceof V1_Profile) {
-            index.profiles.push(el);
-        }
-        else if (el instanceof V1_Measure) {
-            index.measures.push(el);
-        }
-        else if (el instanceof V1_Mapping) {
-            index.mappings.push(el);
-        }
-        else if (el instanceof V1_PackageableConnection) {
-            index.connections.push(el);
-        }
-        else if (el instanceof V1_PackageableRuntime) {
-            index.runtimes.push(el);
-        }
-        else if (el instanceof V1_Store) {
-            index.stores.push(el);
-        }
-        else if (el instanceof V1_SectionIndex) {
-            index.sectionIndices.push(el);
-        }
-        else if (el instanceof V1_Service) {
-            index.services.push(el);
-        }
-        else if (el instanceof V1_FileGenerationSpecification) {
-            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 if (el instanceof V1_ExecutionEnvironmentInstance) {
-            index.executionEnvironments.push(el);
-        }
-        else {
-            const clazz = getClass(el);
-            if (otherElementsByClass.has(clazz)) {
-                otherElementsByClass.get(clazz)?.push(el);
-            }
-            else {
-                otherElementsByClass.set(clazz, [el]);
-            }
-            isIndexedAsOtherElement = true;
-        }
-        if (!isIndexedAsOtherElement) {
-            index.nativeElements.push(el);
-        }
-    });
-    otherElementsByClass.forEach((elements, _class) => {
-        const builder = extensions.getExtraBuilderForProtocolClassOrThrow(_class);
-        index.otherElementsByBuilder.set(builder, (index.otherElementsByBuilder.get(builder) ?? []).concat(elements));
-    });
-    // report
-    report.elementCount.total =
-        (report.elementCount.total ?? 0) + index.elements.length;
-    report.elementCount.other =
-        (report.elementCount.other ?? 0) +
-            otherElementsByClass.size +
-            index.fileGenerations.length +
-            index.generationSpecifications.length;
-    report.elementCount.sectionIndex =
-        (report.elementCount.sectionIndex ?? 0) + index.sectionIndices.length;
-    report.elementCount.association =
-        (report.elementCount.association ?? 0) + index.associations.length;
-    report.elementCount.class =
-        (report.elementCount.class ?? 0) + index.classes.length;
-    report.elementCount.enumeration =
-        (report.elementCount.enumeration ?? 0) + index.enumerations.length;
-    report.elementCount.function =
-        (report.elementCount.function ?? 0) + index.functions.length;
-    report.elementCount.profile =
-        (report.elementCount.profile ?? 0) + index.profiles.length;
-    report.elementCount.measure =
-        (report.elementCount.measure ?? 0) + index.measures.length;
-    report.elementCount.store =
-        (report.elementCount.store ?? 0) + index.stores.length;
-    report.elementCount.mapping =
-        (report.elementCount.mapping ?? 0) + index.mappings.length;
-    report.elementCount.connection =
-        (report.elementCount.connection ?? 0) + index.connections.length;
-    report.elementCount.runtime =
-        (report.elementCount.runtime ?? 0) + index.runtimes.length;
-    report.elementCount.service =
-        (report.elementCount.service ?? 0) + index.services.length;
-    return index;
-};
-class V1_PureGraphManager extends AbstractPureGraphManager {
-    // Pure Client Version represent the version of the pure protocol.
-    // Most Engine APIs will interrupt an undefined pure client version to mean
-    // use the latest production version of the protocol i.e V20_0_0, while version
-    // `VX_X_X` represents the version in development and used for testing
-    static PURE_PROTOCOL_NAME = 'pure';
-    static DEV_PROTOCOL_VERSION = PureClientVersion.VX_X_X;
-    static PROD_PROTOCOL_VERSION = undefined;
-    engine;
-    graphBuilderExtensions;
-    constructor(pluginManager, logService) {
-        super(pluginManager, logService);
-        this.engine = new V1_Engine({}, logService);
-        // setup plugins
-        this.graphBuilderExtensions = new V1_GraphBuilderExtensions(this.pluginManager.getPureProtocolProcessorPlugins());
-        // setup serialization plugins
-        V1_setupPureModelContextDataSerialization(this.pluginManager.getPureProtocolProcessorPlugins());
-        V1_setupDatabaseSerialization(this.pluginManager.getPureProtocolProcessorPlugins());
-        V1_setupEngineRuntimeSerialization(this.pluginManager.getPureProtocolProcessorPlugins());
-        V1_setupLegacyRuntimeSerialization(this.pluginManager.getPureProtocolProcessorPlugins());
-        V1_setupDatabaseBuilderInputSerialization(this.pluginManager.getPureProtocolProcessorPlugins());
-    }
-    TEMPORARY__getEngineConfig() {
-        return this.engine.config;
-    }
-    async initialize(config, options) {
-        this.engine = new V1_Engine(config.clientConfig, this.logService);
-        this.engine
-            .getEngineServerClient()
-            .setTracerService(options?.tracerService ?? new TracerService());
-        await this.engine.setup(config);
-    }
-    getSupportedProtocolVersion() {
-        return PureClientVersion.V1_0_0;
-    }
-    getElementEntities(entities) {
-        return entities.filter((entity) => entity.classifierPath !== CORE_PURE_PATH.SECTION_INDEX);
-    }
-    // --------------------------------------------- Graph Builder ---------------------------------------------
-    async buildSystem(coreModel, systemModel, buildState, options, _report) {
-        const stopWatch = new StopWatch();
-        const report = _report ?? createGraphBuilderReport();
-        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(coreModel, systemModel, this.pluginManager.getPureGraphPlugins());
-        try {
-            // deserialize
-            buildState.setMessage(`Collecting and deserializing elements...`);
-            const systemData = mergePureModelContextData(V1_deserializePureModelContextData(V1_CORE_SYSTEM_MODELS), ...this.pluginManager
-                .getPureProtocolProcessorPlugins()
-                .flatMap((plugin) => plugin.V1_getExtraSystemModels?.() ?? [])
-                .map((modelContextData) => V1_deserializePureModelContextData(modelContextData)));
-            stopWatch.record(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_DESERIALIZE_ELEMENTS__SUCCESS);
-            // prepare build inputs
-            const buildInputs = [
-                {
-                    model: systemModel,
-                    data: V1_indexPureModelContextData(report, systemData, this.graphBuilderExtensions),
-                },
-            ];
-            // build
-            await this.buildGraphFromInputs(graph, buildInputs, report, stopWatch, buildState, options);
-            buildState.pass();
-            const totalTime = stopWatch.elapsed;
-            report.timings = {
-                ...Object.fromEntries(stopWatch.records),
-                [GRAPH_MANAGER_EVENT.GRAPH_BUILDER_BUILD_GRAPH__SUCCESS]: totalTime,
-                total: totalTime,
-            };
-        }
-        catch (error) {
-            assertErrorThrown(error);
-            buildState.fail();
-            this.logService.error(LogEvent.create(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_FAILURE), error);
-            throw new SystemGraphBuilderError(error);
-        }
-        finally {
-            buildState.setMessage(undefined);
-        }
-    }
-    async buildDependencies(coreModel, systemModel, dependencyManager, dependencyEntitiesIndex, buildState, options, _report) {
-        const stopWatch = new StopWatch();
-        const report = _report ?? createGraphBuilderReport();
-        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(coreModel, systemModel, this.pluginManager.getPureGraphPlugins());
-        graph.dependencyManager = dependencyManager;
-        try {
-            dependencyManager.initialize(dependencyEntitiesIndex);
-            // deserialize
-            buildState.setMessage(`Partitioning and deserializing elements...`);
-            const dependencyGraphDataIndex = new Map();
-            await Promise.all(Array.from(dependencyEntitiesIndex.entries()).map(([dependencyKey, entitiesWithOrigin]) => {
-                const projectModelData = new V1_PureModelContextData();
-                dependencyGraphDataIndex.set(dependencyKey, projectModelData);
-                return V1_entitiesToPureModelContextData(entitiesWithOrigin.entities, projectModelData, this.pluginManager.getPureProtocolProcessorPlugins());
-            }));
-            stopWatch.record(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_DESERIALIZE_ELEMENTS__SUCCESS);
-            // prepare build inputs
-            const buildInputs = Array.from(dependencyGraphDataIndex.entries()).map(([dependencyKey, dependencyData]) => ({
-                model: graph.dependencyManager.getModel(dependencyKey),
-                data: V1_indexPureModelContextData(report, dependencyData, this.graphBuilderExtensions),
-            }));
-            // build
-            await this.buildGraphFromInputs(graph, buildInputs, report, stopWatch, buildState, options);
-            buildState.pass();
-            const totalTime = stopWatch.elapsed;
-            report.timings = {
-                ...Object.fromEntries(stopWatch.records),
-                [GRAPH_MANAGER_EVENT.GRAPH_BUILDER_BUILD_GRAPH__SUCCESS]: totalTime,
-                total: totalTime,
-            };
-        }
-        catch (error) {
-            assertErrorThrown(error);
-            this.logService.error(LogEvent.create(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_FAILURE), error);
-            buildState.fail();
-            throw new DependencyGraphBuilderError(error);
-        }
-        finally {
-            buildState.setMessage(undefined);
-        }
-    }
-    async buildGraph(graph, entities, buildState, options, _report) {
-        const stopWatch = new StopWatch();
-        const report = _report ?? createGraphBuilderReport();
-        buildState.reset();
-        try {
-            // deserialize
-            buildState.setMessage(`Deserializing elements...`);
-            const data = new V1_PureModelContextData();
-            await V1_entitiesToPureModelContextData(entities, data, this.pluginManager.getPureProtocolProcessorPlugins());
-            stopWatch.record(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_DESERIALIZE_ELEMENTS__SUCCESS);
-            // prepare build inputs
-            const buildInputs = [
-                {
-                    model: graph,
-                    data: V1_indexPureModelContextData(report, data, this.graphBuilderExtensions),
-                },
-            ];
-            // build
-            await this.buildGraphFromInputs(graph, buildInputs, report, stopWatch, buildState, 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__preserveSectionIndex) {
-                graph.TEMPORARY__deleteOwnSectionIndex();
-            }
-            /**
-             * This sets the SDLC of the graph if there exists a versioned `SDLC` of the graph. This means the graph is immutable and we can easily `refetch`
-             * the graph with the provided sdlc pointer
-             */
-            if (options?.origin) {
-                graph.setOrigin(options.origin);
-            }
-            buildState.pass();
-            const totalTime = stopWatch.elapsed;
-            report.timings = {
-                ...Object.fromEntries(stopWatch.records),
-                [GRAPH_MANAGER_EVENT.GRAPH_BUILDER_BUILD_GRAPH__SUCCESS]: totalTime,
-                total: totalTime,
-            };
-        }
-        catch (error) {
-            assertErrorThrown(error);
-            this.logService.error(LogEvent.create(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_FAILURE), error);
-            buildState.fail();
-            /**
-             * Wrap all error with `GraphBuilderError`, as we throw a lot of assertion error in the graph builder
-             * But we might want to rethink this decision in the future and throw appropriate type of error
-             */
-            throw error instanceof GraphBuilderError
-                ? error
-                : new GraphBuilderError(error);
-        }
-        finally {
-            buildState.setMessage(undefined);
-        }
-    }
-    async buildLightGraph(graph, entities, buildState, options, _report) {
-        const stopWatch = new StopWatch();
-        const report = _report ?? createGraphBuilderReport();
-        buildState.reset();
-        try {
-            // deserialize
-            buildState.setMessage(`Deserializing elements...`);
-            const data = new V1_PureModelContextData();
-            await V1_entitiesToPureModelContextData(entities, data, this.pluginManager.getPureProtocolProcessorPlugins());
-            stopWatch.record(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_DESERIALIZE_ELEMENTS__SUCCESS);
-            // prepare build inputs
-            const buildInputs = [
-                {
-                    model: graph,
-                    data: V1_indexPureModelContextData(report, data, this.graphBuilderExtensions),
-                },
-            ];
-            // build
-            await this.buildLightGraphFromInputs(graph, buildInputs, report, stopWatch, buildState, 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__preserveSectionIndex) {
-                graph.TEMPORARY__deleteOwnSectionIndex();
-            }
-            buildState.pass();
-            const totalTime = stopWatch.elapsed;
-            report.timings = {
-                ...Object.fromEntries(stopWatch.records),
-                [GRAPH_MANAGER_EVENT.GRAPH_BUILDER_BUILD_GRAPH__SUCCESS]: totalTime,
-                total: totalTime,
-            };
-        }
-        catch (error) {
-            assertErrorThrown(error);
-            this.logService.error(LogEvent.create(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_FAILURE), error);
-            buildState.fail();
-            /**
-             * Wrap all error with `GraphBuilderError`, as we throw a lot of assertion error in the graph builder
-             * But we might want to rethink this decision in the future and throw appropriate type of error
-             */
-            throw error instanceof GraphBuilderError
-                ? error
-                : new GraphBuilderError(error);
-        }
-        finally {
-            buildState.setMessage(undefined);
-        }
-    }
-    async buildGenerations(graph, generatedEntities, buildState, options, _report) {
-        const stopWatch = new StopWatch();
-        const report = _report ?? createGraphBuilderReport();
-        const generatedModel = graph.generationModel;
-        buildState.reset();
-        try {
-            // deserialize
-            buildState.setMessage(`Deserializing elements...`);
-            const generationGraphDataIndex = new Map();
-            await Promise.all(Array.from(generatedEntities.entries()).map(([generationParentPath, entities]) => {
-                const generatedData = new V1_PureModelContextData();
-                generationGraphDataIndex.set(generationParentPath, generatedData);
-                return V1_entitiesToPureModelContextData(entities, generatedData, this.pluginManager.getPureProtocolProcessorPlugins());
-            }));
-            stopWatch.record(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_DESERIALIZE_ELEMENTS__SUCCESS);
-            // prepare build inputs
-            const buildInputs = Array.from(generationGraphDataIndex.entries()).map(([generationParentPath, generatedData]) => ({
-                model: generatedModel,
-                data: V1_indexPureModelContextData(report, generatedData, this.graphBuilderExtensions),
-            }));
-            // build
-            await this.buildGraphFromInputs(graph, buildInputs, report, stopWatch, buildState, options);
-            buildState.pass();
-            const totalTime = stopWatch.elapsed;
-            report.timings = {
-                ...Object.fromEntries(stopWatch.records),
-                [GRAPH_MANAGER_EVENT.GRAPH_BUILDER_BUILD_GRAPH__SUCCESS]: totalTime,
-                total: totalTime,
-            };
-        }
-        catch (error) {
-            assertErrorThrown(error);
-            this.logService.error(LogEvent.create(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_FAILURE), error);
-            buildState.fail();
-            /**
-             * Wrap all error with `GraphBuilderError`, as we throw a lot of assertion error in the graph builder
-             * But we might want to rethink this decision in the future and throw appropriate type of error
-             */
-            throw error instanceof GraphBuilderError
-                ? error
-                : new GraphBuilderError(error);
-        }
-        finally {
-            buildState.setMessage(undefined);
-        }
-    }
-    async buildGraphFromInputs(graph, inputs, report, stopWatch, graphBuilderState, options) {
-        // index
-        graphBuilderState.setMessage(`Indexing ${report.elementCount.total} elements...`);
-        await this.initializeAndIndexElements(graph, inputs, options);
-        stopWatch.record(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_INDEX_ELEMENTS__SUCCESS);
-        // build section index
-        graphBuilderState.setMessage(`Building section indices...`);
-        await this.buildSectionIndices(graph, inputs, options);
-        stopWatch.record(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_BUILD_SECTION_INDICES__SUCCESS);
-        // build types
-        graphBuilderState.setMessage(`Building domain models...`);
-        await this.buildTypes(graph, inputs, options);
-        stopWatch.record(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_BUILD_DOMAIN_MODELS__SUCCESS);
-        // build stores
-        graphBuilderState.setMessage(`Building stores...`);
-        await this.buildStores(graph, inputs, options);
-        stopWatch.record(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_BUILD_STORES__SUCCESS);
-        // build mappings
-        graphBuilderState.setMessage(`Building mappings...`);
-        await this.buildMappings(graph, inputs, options);
-        stopWatch.record(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_BUILD_MAPPINGS__SUCCESS);
-        // build connections and runtimes
-        graphBuilderState.setMessage(`Building connections and runtimes...`);
-        await this.buildConnectionsAndRuntimes(graph, inputs, options);
-        stopWatch.record(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_BUILD_CONNECTIONS_AND_RUNTIMES__SUCCESS);
-        // build services
-        graphBuilderState.setMessage(`Building services and execution environments...`);
-        await this.buildServices(graph, inputs, options);
-        stopWatch.record(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_BUILD_SERVICES__SUCCESS);
-        // build data elements
-        graphBuilderState.setMessage(`Building data elements...`);
-        await this.buildDataElements(graph, inputs, options);
-        stopWatch.record(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_BUILD_DATA_ELEMENTS__SUCCESS);
-        // build other elements
-        graphBuilderState.setMessage(`Building other elements...`);
-        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_BUILD_OTHER_ELEMENTS__SUCCESS);
-    }
-    async buildLightGraphFromInputs(graph, inputs, report, stopWatch, graphBuilderState, options) {
-        // index
-        graphBuilderState.setMessage(`Indexing ${report.elementCount.total} elements...`);
-        await this.initializeAndIndexElements(graph, inputs, options);
-        stopWatch.record(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_INDEX_ELEMENTS__SUCCESS);
-    }
-    getBuilderContext(graph, currentSubGraph, element, options) {
-        return new V1_GraphBuilderContextBuilder(graph, currentSubGraph, this.graphBuilderExtensions, this.logService, options)
-            .withElement(element)
-            .build();
-    }
-    /**
-     * This will run the first pass builder for all elements and index them.
-     * This process is needed so other core processes such as building the section indices
-     * or building processes that relies on the `existence` of other elements to refer to them,
-     * but not necessarily use them.
-     *
-     * NOTE: We aim to not do anything more than running the first pass and indexing the first pass.
-     */
-    async initializeAndIndexElements(graph, inputs, 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_ElementFirstPassBuilder(this.getBuilderContext(graph, input.model, element, options), packageCache, elementPathCache))));
-            await Promise.all(this.graphBuilderExtensions.sortedExtraElementBuilders.flatMap(async (builder) => (input.data.otherElementsByBuilder.get(builder) ?? []).map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementFirstPassBuilder(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.visitWithGraphBuilderErrorHandling(element, new V1_ElementSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
-        await Promise.all(inputs.flatMap((input) => input.data.classes.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
-        await Promise.all(inputs.flatMap((input) => input.data.enumerations.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
-        await Promise.all(inputs.flatMap((input) => input.data.measures.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
-        await Promise.all(inputs.flatMap((input) => input.data.functions.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
-        // Third pass
-        await Promise.all(inputs.flatMap((input) => input.data.classes.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementThirdPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
-        await Promise.all(inputs.flatMap((input) => input.data.associations.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementThirdPassBuilder(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_ElementFourthPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
-        await Promise.all(inputs.flatMap((input) => input.data.associations.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementFourthPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
-        // Fifth pass
-        await Promise.all(inputs.flatMap((input) => input.data.classes.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementFifthPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
-    }
-    async buildStores(graph, inputs, options) {
-        await Promise.all(inputs.flatMap((input) => input.data.stores.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
-        await Promise.all(inputs.flatMap((input) => input.data.stores.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementThirdPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
-        await Promise.all(inputs.flatMap((input) => input.data.stores.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementFourthPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
-        await Promise.all(inputs.flatMap((input) => input.data.stores.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementFifthPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
-    }
-    async buildMappings(graph, inputs, options) {
-        await Promise.all(inputs.flatMap((input) => input.data.mappings.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
-        await Promise.all(inputs.flatMap((input) => input.data.mappings.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementThirdPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
-        await Promise.all(inputs.flatMap((input) => input.data.mappings.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementFourthPassBuilder(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.visitWithGraphBuilderErrorHandling(element, new V1_ElementSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
-        await Promise.all(inputs.flatMap((input) => input.data.runtimes.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
-    }
-    async buildServices(graph, inputs, options) {
-        await Promise.all(inputs.flatMap((input) => input.data.services.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
-        await Promise.all(inputs.flatMap((input) => input.data.executionEnvironments.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementSecondPassBuilder(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_ElementSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
-    }
-    async buildFileGenerations(graph, inputs, options) {
-        await Promise.all(inputs.flatMap((input) => input.data.fileGenerations.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
-    }
-    async buildGenerationSpecifications(graph, inputs, options) {
-        await Promise.all(inputs.flatMap((input) => input.data.generationSpecifications.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
-    }
-    async buildSectionIndices(graph, inputs, options) {
-        await Promise.all(inputs.flatMap((input) => input.data.sectionIndices.map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementSecondPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
-    }
-    async buildOtherElements(graph, inputs, options) {
-        await Promise.all(this.graphBuilderExtensions.sortedExtraElementBuilders.map(async (builder) => {
-            await Promise.all(inputs.flatMap((input) => (input.data.otherElementsByBuilder.get(builder) ?? []).map((element) => this.visitWithGraphBuilderErrorHandling(element, new V1_ElementSecondPassBuilder(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_ElementThirdPassBuilder(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_ElementFourthPassBuilder(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_ElementFifthPassBuilder(this.getBuilderContext(graph, input.model, element, options))))));
-        }));
-    }
-    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 = `Can't build element '${element.path}': ${err.message}`;
-            throw error;
-        }
-    }
-    // --------------------------------------------- Grammar ---------------------------------------------
-    async graphToPureCode(graph) {
-        const startTime = Date.now();
-        const graphData = this.graphToPureModelContextData(graph);
-        const grammarToJson = await this.engine.pureModelContextDataToPureCode(graphData);
-        this.logService.info(LogEvent.create(GRAPH_MANAGER_EVENT.TRANSFORM_GRAPH_META_MODEL_TO_GRAMMAR__SUCCESS), Date.now() - startTime, 'ms');
-        return grammarToJson;
-    }
-    async prettyLambdaContent(lambda) {
-        return this.engine.prettyLambdaContent(lambda);
-    }
-    async entitiesToPureCode(entities) {
-        const startTime = Date.now();
-        const grammarToJson = await this.engine.pureModelContextDataToPureCode(await this.entitiesToPureModelContextData(entities));
-        this.logService.info(LogEvent.create(GRAPH_MANAGER_EVENT.TRANSFORM_GRAPH_META_MODEL_TO_GRAMMAR__SUCCESS), Date.now() - startTime, 'ms');
-        return grammarToJson;
-    }
-    async pureCodeToEntities(code, options) {
-        const pmcd = await this.engine.pureCodeToPureModelContextData(code);
-        pmcd.elements = pmcd.elements.filter((el) => options?.TEMPORARY__keepSectionIndex ??
-            !(el instanceof V1_SectionIndex));
-        return this.pureModelContextDataToEntities(pmcd);
-    }
-    async pureCodeToLambda(lambda, lambdaId, options) {
-        const result = await this.engine.transformCodeToLambda(lambda, lambdaId, options);
-        return new RawLambda(result.parameters, result.body);
-    }
-    async lambdaToPureCode(lambda, pretty) {
-        return this.engine.transformLambdaToCode(lambda, Boolean(pretty), this.pluginManager.getPureProtocolProcessorPlugins());
-    }
-    lambdasToPureCode(lambdas, pretty) {
-        return this.engine.transformLambdasToCode(lambdas, Boolean(pretty), this.pluginManager.getPureProtocolProcessorPlugins());
-    }
-    pureCodeToRelationalOperationElement(operation, operationId) {
-        return this.engine.transformPureCodeToRelationalOperationElement(operation, operationId);
-    }
-    relationalOperationElementToPureCode(operations) {
-        return this.engine.transformRelationalOperationElementsToPureCode(operations);
-    }
-    // ------------------------------------------- Compile -------------------------------------------
-    async compileEntities(entities) {
-        await this.engine.compilePureModelContextData(await this.entitiesToPureModelContextData(entities));
-    }
-    async compileGraph(graph, options, _report) {
-        const report = _report ?? createGraphManagerOperationReport();
-        const stopWatch = new StopWatch();
-        const graphData = this.getFullGraphModelData(graph, {
-            keepSourceInformation: options?.keepSourceInformation,
-        });
-        stopWatch.record(GRAPH_MANAGER_EVENT.V1_ENGINE_OPERATION_INPUT__SUCCESS);
-        const compilationResult = await this.engine.compilePureModelContextData(graphData, {
-            onError: options?.onError,
-        });
-        stopWatch.record(GRAPH_MANAGER_EVENT.V1_ENGINE_OPERATION_SERVER_CALL__SUCCESS);
-        report.timings = {
-            ...Object.fromEntries(stopWatch.records),
-            total: stopWatch.elapsed,
-        };
-        return {
-            warnings: compilationResult.warnings?.map((warning) => new CompilationWarning(warning.message, warning.sourceInformation)),
-        };
-    }
-    async compileText(graphGrammar, graph, options, _report) {
-        const report = _report ?? createGraphManagerOperationReport();
-        const stopWatch = new StopWatch();
-        const graphCompileContext = this.getGraphCompileContext(graph);
-        stopWatch.record(GRAPH_MANAGER_EVENT.V1_ENGINE_OPERATION_INPUT__SUCCESS);
-        const compilationResult = await this.engine.compileText(graphGrammar, report, graphCompileContext, options);
-        const entities = this.pureModelContextDataToEntities(compilationResult.model);
-        report.timings = {
-            ...report.timings,
-            ...Object.fromEntries(stopWatch.records),
-            total: stopWatch.elapsed,
-        };
-        return {
-            entities,
-            warnings: compilationResult.warnings?.map((warning) => new CompilationWarning(warning.message, warning.sourceInformation)),
-        };
-    }
-    getLambdaReturnType(lambda, graph, options) {
-        return this.engine.getLambdaReturnType(this.buildLambdaReturnTypeInput(lambda, graph, options));
-    }
-    buildLambdaReturnTypeInput(lambda, graph, options) {
-        return new V1_LambdaReturnTypeInput(this.getFullGraphModelContext(graph, V1_PureGraphManager.DEV_PROTOCOL_VERSION), lambda.accept_RawValueSpecificationVisitor(new V1_RawValueSpecificationTransformer(new V1_GraphTransformerContextBuilder(this.pluginManager.getPureProtocolProcessorPlugins())
-            .withKeepSourceInformationFlag(Boolean(options?.keepSourceInformation))
-            .build())));
-    }
-    // ------------------------------------------- Generation -------------------------------------------
-    getAvailableGenerationConfigurationDescriptions() {
-        return this.engine.getAvailableGenerationConfigurationDescriptions();
-    }
-    async generateFile(fileGeneration, generationMode, graph) {
-        const config = {};
-        config.scopeElements = fileGeneration.scopeElements.map((element) => element instanceof PackageableElementReference
-            ? element.value.path
-            : element);
-        fileGeneration.configurationProperties.forEach((property) => {
-            config[property.name] = property.value;
-        });
-        return (await this.engine.generateFile(config, fileGeneration.type, generationMode, this.getFullGraphModelData(graph))).map(V1_buildGenerationOutput);
-    }
-    async generateModel(generationElement, graph) {
-        const model = this.getFullGraphModelData(graph);
-        let generatedModel = undefined;
-        const extraModelGenerators = this.pluginManager
-            .getPureProtocolProcessorPlugins()
-            .flatMap((plugin) => plugin.V1_getExtraModelGenerators?.() ?? []);
-        for (const generator of extraModelGenerators) {
-            const _model = await generator(generationElement, model, this.engine);
-            if (_model) {
-                generatedModel = _model;
-                break;
-            }
-        }
-        if (!generatedModel) {
-            throw new UnsupportedOperationError(`Can't generate model using the specified generation element: no compatible generator available from plugins`, generationElement);
-        }
-        return this.pureModelContextDataToEntities(generatedModel);
-    }
-    // ------------------------------------------- Test  -------------------------------------------
-    async runTests(inputs, graph) {
-        const runTestsInput = new V1_RunTestsInput();
-        runTestsInput.model = this.getFullGraphModelContext(graph, V1_PureGraphManager.DEV_PROTOCOL_VERSION);
-        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_UniqueTestId();
-                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) => getNullableTestable(id, graph, this.pluginManager.getPureGraphManagerPlugins()), this.pluginManager.getPureProtocolProcessorPlugins());
-        return result;
-    }
-    async generateExpectedResult(testable, test, baseAssertion, graph) {
-        const id = uuid();
-        try {
-            baseAssertion.id = id;
-            addUniqueEntry(test.assertions, baseAssertion);
-            const runTestsInput = new V1_RunTestsInput();
-            runTestsInput.model = this.getFullGraphModelData(graph);
-            const runTestableInput = new V1_RunTestsTestableInput();
-            const unitAtomicTest = new V1_UniqueTestId();
-            runTestableInput.testable = guaranteeNonNullable(getNullableIDFromTestable(testable, graph, this.pluginManager.getPureGraphManagerPlugins()));
-            runTestableInput.unitTestIds = [unitAtomicTest];
-            runTestsInput.testables = [runTestableInput];
-            const parent = test.__parent;
-            unitAtomicTest.testSuiteId =
-                parent instanceof TestSuite ? parent.id : undefined;
-            unitAtomicTest.atomicTestId = test.id;
-            const runTestsResult = await this.engine.runTests(runTestsInput);
-            const results = V1_buildTestsResult(runTestsResult, (_id) => getNullableTestable(_id, graph, this.pluginManager.getPureGraphManagerPlugins()), this.pluginManager.getPureProtocolProcessorPlugins());
-            const result = results[0];
-            let status = undefined;
-            if (result instanceof TestExecuted &&
-                result.testExecutionStatus === TestExecutionStatus.FAIL) {
-                status = result.assertStatuses.find((aStatus) => aStatus.assertion === baseAssertion &&
-                    aStatus instanceof AssertFail);
-            }
-            else if (result instanceof MultiExecutionServiceTestResult) {
-                status = Array.from(result.keyIndexedTestResults.values())
-                    .map((testResult) => {
-                    if (testResult instanceof TestExecuted &&
-                        testResult.testExecutionStatus === TestExecutionStatus.FAIL) {
-                        return testResult.assertStatuses.find((aStatus) => aStatus.assertion === baseAssertion &&
-                            aStatus instanceof AssertFail);
-                    }
-                    else if (testResult instanceof TestError) {
-                        throw new IllegalStateError(testResult.error);
-                    }
-                    return undefined;
-                })
-                    .filter(isNonNullable)[0];
-            }
-            else if (result instanceof TestError) {
-                throw new IllegalStateError(result.error);
-            }
-            else {
-                throw new UnsupportedOperationError('Unable to derive expected result from test result');
-            }
-            return guaranteeNonNullable(status);
-        }
-        catch (error) {
-            assertErrorThrown(error);
-            throw error;
-        }
-        finally {
-            deleteEntry(test.assertions, baseAssertion);
-        }
-    }
-    // ------------------------------------------- Value Specification -------------------------------------------
-    buildValueSpecification(json, graph) {
-        return V1_buildValueSpecification(V1_deserializeValueSpecification(json, this.pluginManager.getPureProtocolProcessorPlugins()), new V1_GraphBuilderContextBuilder(graph, graph, this.graphBuilderExtensions, this.logService).build());
-    }
-    serializeValueSpecification(valueSpecification) {
-        return V1_serializeValueSpecification(V1_transformRootValueSpecification(valueSpecification), this.pluginManager.getPureProtocolProcessorPlugins());
-    }
-    buildRawValueSpecification(valueSpecification, graph) {
-        // converts value spec to json
-        const json = this.serializeValueSpecification(valueSpecification);
-        // deserialize json and builds metamodal raw value spec
-        const rawValueSpecification = V1_deserializeRawValueSpecification(json);
-        return rawValueSpecification.accept_RawValueSpecificationVisitor(new V1_RawValueSpecificationBuilder(new V1_GraphBuilderContextBuilder(graph, graph, this.graphBuilderExtensions, this.logService).build()));
-    }
-    serializeRawValueSpecification(metamodel) {
-        return V1_serializeRawValueSpecification(metamodel.accept_RawValueSpecificationVisitor(new V1_RawValueSpecificationTransformer(new V1_GraphTransformerContextBuilder(this.pluginManager.getPureProtocolProcessorPlugins()).build())));
-    }
-    createGetAllRawLambda(_class) {
-        return new RawLambda([], [
-            {
-                _type: 'func',
-                function: 'getAll',
-                parameters: [
-                    {
-                        _type: 'packageableElementPtr',
-                        fullPath: _class.path,
-                    },
-                ],
-            },
-        ]);
-    }
-    createDefaultBasicRawLambda(options) {
-        return new RawLambda(options?.addDummyParameter ? [{ _type: 'var', name: 'x' }] : undefined, [
-            {
-                _type: 'string',
-                multiplicity: { lowerBound: 1, upperBound: 1 },
-                values: [''],
-            },
-        ]);
-    }
-    // ------------------------------------------- External Format --------------------------------
-    getAvailableExternalFormatsDescriptions() {
-        return this.engine.getAvailableExternalFormatsDescriptions();
-    }
-    generateModelFromExternalFormat(schemaSet, targetBinding, configurationProperties, graph) {
-        const config = {};
-        configurationProperties.forEach((property) => {
-            config[property.name] = property.value;
-        });
-        const model = this.getFullGraphModelData(graph);
-        const input = new V1_ExternalFormatModelGenerationInput(schemaSet.path, model, config);
-        if (targetBinding) {
-            input.generateBinding = true;
-            input.targetBindingPath = targetBinding;
-        }
-        // TODO: once api defaults to latest prod pure client version
-        input.clientVersion = PureClientVersion.VX_X_X;
-        return this.engine.generateModel(input);
-    }
-    async generateSchemaFromExternalFormatConfig(modelUnit, targetBinding, configurationProperties, currentGraph) {
-        const config = {};
-        configurationProperties.forEach((property) => {
-            config[property.name] = property.value;
-        });
-        const input = new V1_GenerateSchemaInput(V1_transformModelUnit(modelUnit), this.getFullGraphModelData(currentGraph), Boolean(targetBinding), config);
-        input.targetBindingPath = targetBinding;
-        const genPMCD = await this.engine.generateSchema(input);
-        const genGraph = await this.createEmptyGraph();
-        const report = createGraphBuilderReport();
-        const mainGraphBuilderInput = [
-            {
-                model: genGraph,
-                data: V1_indexPureModelContextData(report, genPMCD, this.graphBuilderExtensions),
-            },
-        ];
-        await this.buildGraphFromInputs(genGraph, mainGraphBuilderInput, report, new StopWatch(), ActionState.create());
-        return genGraph.allElements.filter(filterByType(SchemaSet));
-    }
-    // ------------------------------------------- Import -------------------------------------------
-    getExamplePureProtocolText() {
-        return JSON.stringify(new V1_PureModelContextData(), undefined, this.engine.config.tabSize);
-    }
-    getExampleExternalFormatImportText() {
-        return JSON.stringify({
-            package: 'string (optional)',
-            imports: [
-                {
-                    fileName: 'string (optional)',
-                    content: 'string (optional)',
-                },
-            ],
-        }, undefined, this.engine.config.tabSize);
-    }
-    async entitiesToPureProtocolText(entities) {
-        return JSON.stringify(V1_serializePureModelContext(await this.entitiesToPureModelContextData(entities)), undefined, this.engine.config.tabSize);
-    }
-    pureProtocolTextToEntities = (protocol) => {
-        const graphData = V1_deserializePureModelContextData(JSON.parse(protocol));
-        return this.pureModelContextDataToEntities(graphData);
-    };
-    // --------------------------------------------- Execution ---------------------------------------------
-    createExecutionInput = (graph, mapping, lambda, runtime, clientVersion, parameterValues) => this.buildExecutionInput(graph, mapping, lambda, runtime, clientVersion, new V1_ExecuteInput(), parameterValues);
-    buildExecutionInput = (graph, mapping, lambda, runtime, clientVersion, executeInput, parameterValues) => {
-        const pureModelContext = graph.origin
-            ? this.buildPureModelSDLCPointer(graph.origin, undefined)
-            : this.buildExecutionInputGraphData(graph, mapping, runtime);
-        return this.buildExecutionInputWithPureModelContext(pureModelContext, mapping, lambda, runtime, clientVersion, executeInput, parameterValues);
-    };
-    buildExecutionInputWithPureModelContext = (pureModelContext, mapping, lambda, runtime, clientVersion, executeInput, parameterValues) => {
-        // 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.
-        executeInput.clientVersion = clientVersion;
-        executeInput.function = V1_transformRawLambda(lambda, new V1_GraphTransformerContextBuilder(this.pluginManager.getPureProtocolProcessorPlugins()).build());
-        executeInput.mapping = mapping?.path;
-        executeInput.runtime = runtime
-            ? V1_transformRuntime(runtime, new V1_GraphTransformerContextBuilder(this.pluginManager.getPureProtocolProcessorPlugins()).build())
-            : undefined;
-        executeInput.model = pureModelContext;
-        executeInput.context = new V1_RawBaseExecutionContext(); // TODO: potentially need to support more types
-        if (parameterValues) {
-            executeInput.parameterValues = parameterValues.map((p) => V1_transformParameterValue(p));
-        }
-        return executeInput;
-    };
-    buildExecutionInputGraphData(graph, mapping, runtime) {
-        /**
-         * 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
-         *
-         * Graph data models can be classified based on dependency hieararchy:
-         * 1. Building blocks: models that all other models depend on: e.g. domain models, connections, etc.
-         * 2. Consumers: models that depends on other models: e.g. mapping, service, etc.
-         * 3. Unrelated: models that depends on nothing and vice versa: e.g. text
-         *
-         * It would be great if we can provide a way to walk the mapping to select only relevant part, but the problem is we cannot really walk the lambda
-         * object to identify relevant classes yet. so the more economical way to to base on the classification above and the knowledge about hierarchy between
-         * models (e.g. service can use mapping, runtime, connection, store, etc.) we can roughly prune the graph model data by group. Following is an example
-         * for mapping used for execution, but this can generalized if we introduce hierarchy/ranking for model type
-         */
-        const graphData = this.getFullGraphModelData(graph);
-        const prunedGraphData = new V1_PureModelContextData();
-        const extraExecutionElements = this.pluginManager
-            .getPureProtocolProcessorPlugins()
-            .flatMap((element) => element.V1_getExtraExecutionInputCollectors?.() ?? [])
-            .flatMap((getter) => getter(graph, mapping, runtime, graphData));
-        prunedGraphData.elements = uniq(graphData.elements
-            .filter((element) => element instanceof V1_Class ||
-            element instanceof V1_Enumeration ||
-            element instanceof V1_Profile ||
-            element instanceof V1_Association ||
-            element instanceof V1_ConcreteFunctionDefinition ||
-            element instanceof V1_Measure ||
-            element instanceof V1_Store ||
-            element instanceof V1_PackageableConnection ||
-            element instanceof V1_PackageableRuntime ||
-            element instanceof V1_Mapping)
-            .concat(extraExecutionElements));
-        return prunedGraphData;
-    }
-    async runQuery(lambda, mapping, runtime, graph, options, _report) {
-        const report = _report ?? createGraphManagerOperationReport();
-        const stopWatch = new StopWatch();
-        const input = this.createExecutionInput(graph, mapping, lambda, runtime, V1_PureGraphManager.PROD_PROTOCOL_VERSION, options?.parameterValues);
-        stopWatch.record(GRAPH_MANAGER_EVENT.V1_ENGINE_OPERATION_INPUT__SUCCESS);
-        const result = V1_buildExecutionResult(await this.engine.executeMapping(input, options));
-        stopWatch.record(GRAPH_MANAGER_EVENT.V1_ENGINE_OPERATION_SERVER_CALL__SUCCESS);
-        report.timings = {
-            ...Object.fromEntries(stopWatch.records),
-            total: stopWatch.elapsed,
-        };
-        return result;
-    }
-    async DEPRECATED__runLegacyMappingTests(tests, mapping, graph, options, _report) {
-        const report = _report ?? createGraphManagerOperationReport();
-        const stopWatch = new StopWatch();
-        const pureModelContext = graph.origin
-            ? this.buildPureModelSDLCPointer(graph.origin, undefined)
-            : this.buildExecutionInputGraphData(graph, mapping, undefined);
-        stopWatch.record(GRAPH_MANAGER_EVENT.V1_ENGINE_OPERATION_INPUT__SUCCESS);
-        await Promise.all(tests.map((t) => this.DEPRECATED__runLegacyMappingTest(t, mapping, pureModelContext, options, report)));
-    }
-    async DEPRECATED__runLegacyMappingTest(testInfo, mapping, pureModelContext, options, _report) {
-        const report = _report ?? createGraphManagerOperationReport();
-        try {
-            const stopWatch = new StopWatch();
-            stopWatch.record(GRAPH_MANAGER_EVENT.V1_ENGINE_OPERATION_INPUT__SUCCESS);
-            DEPRECATED__validate_MappingTest(testInfo.test);
-            const input = this.buildExecutionInputWithPureModelContext(pureModelContext, mapping, testInfo.test.query, testInfo.runtime, V1_PureGraphManager.PROD_PROTOCOL_VERSION, new V1_ExecuteInput(), options?.parameterValues);
-            const result = V1_buildExecutionResult(await this.engine.executeMapping(input, options));
-            stopWatch.record(GRAPH_MANAGER_EVENT.V1_ENGINE_OPERATION_SERVER_CALL__SUCCESS);
-            report.timings = {
-                ...Object.fromEntries(stopWatch.records),
-                total: stopWatch.elapsed,
-            };
-            testInfo.handleResult(result);
-        }
-        catch (error) {
-            assertErrorThrown(error);
-            testInfo.handleError(error);
-        }
-    }
-    async generateExecutionPlan(lambda, mapping, runtime, graph, _report) {
-        const report = _report ?? createGraphManagerOperationReport();
-        const stopWatch = new StopWatch();
-        const input = this.createExecutionInput(graph, mapping, lambda, runtime, V1_PureGraphManager.DEV_PROTOCOL_VERSION);
-        stopWatch.record(GRAPH_MANAGER_EVENT.V1_ENGINE_OPERATION_INPUT__SUCCESS);
-        const result = await this.engine.generateExecutionPlan(input);
-        stopWatch.record(GRAPH_MANAGER_EVENT.V1_ENGINE_OPERATION_SERVER_CALL__SUCCESS);
-        report.timings = {
-            ...Object.fromEntries(stopWatch.records),
-            total: stopWatch.elapsed,
-        };
-        return result;
-    }
-    async debugExecutionPlanGeneration(lambda, mapping, runtime, graph, _report) {
-        const report = _report ?? createGraphManagerOperationReport();
-        const stopWatch = new StopWatch();
-        const input = this.createExecutionInput(graph, mapping, lambda, runtime, V1_PureGraphManager.DEV_PROTOCOL_VERSION);
-        stopWatch.record(GRAPH_MANAGER_EVENT.V1_ENGINE_OPERATION_INPUT__SUCCESS);
-        const result = await this.engine.debugExecutionPlanGeneration(input);
-        stopWatch.record(GRAPH_MANAGER_EVENT.V1_ENGINE_OPERATION_SERVER_CALL__SUCCESS);
-        report.timings = {
-            ...Object.fromEntries(stopWatch.records),
-            total: stopWatch.elapsed,
-        };
-        return {
-            plan: result.plan,
-            debug: result.debug.join('\n'),
-        };
-    }
-    async generateExecuteTestData(lambda, parameters, mapping, runtime, graph, options, _report) {
-        const report = _report ?? createGraphManagerOperationReport();
-        const stopWatch = new StopWatch();
-        const testDataGenerationExecuteInput = new V1_TestDataGenerationExecutionInput();
-        this.buildExecutionInput(graph, mapping, lambda, runtime, V1_PureGraphManager.DEV_PROTOCOL_VERSION, testDataGenerationExecuteInput);
-        testDataGenerationExecuteInput.parameters = parameters;
-        testDataGenerationExecuteInput.hashStrings = Boolean(options?.anonymizeGeneratedData);
-        stopWatch.record(GRAPH_MANAGER_EVENT.V1_ENGINE_OPERATION_INPUT__SUCCESS);
-        const result = await this.engine.generateExecuteTestData(testDataGenerationExecuteInput);
-        stopWatch.record(GRAPH_MANAGER_EVENT.V1_ENGINE_OPERATION_SERVER_CALL__SUCCESS);
-        report.timings = {
-            ...Object.fromEntries(stopWatch.records),
-            total: stopWatch.elapsed,
-        };
-        return result;
-    }
-    buildExecutionPlan(executionPlanJson, graph) {
-        return V1_buildExecutionPlan(V1_deserializeExecutionPlan(executionPlanJson), new V1_GraphBuilderContextBuilder(graph, graph, this.graphBuilderExtensions, this.logService).build());
-    }
-    serializeExecutionPlan(executionPlan) {
-        return V1_serializeExecutionPlan(V1_transformExecutionPlan(executionPlan, new V1_GraphTransformerContextBuilder(this.pluginManager.getPureProtocolProcessorPlugins()).build()));
-    }
-    serializeExecutionNode(executionNode) {
-        return V1_serializeExecutionNode(V1_transformExecutionNode(executionNode, new V1_GraphTransformerContextBuilder(this.pluginManager.getPureProtocolProcessorPlugins()).build()));
-    }
-    // --------------------------------------------- Service ---------------------------------------------
-    async registerService(service, graph, groupId, artifactId, version, server, executionMode, options) {
-        const serverServiceInfo = await this.engine.getServerServiceInfo();
-        // input
-        let input;
-        const protocol = new V1_Protocol(V1_PureGraphManager.PURE_PROTOCOL_NAME, serverServiceInfo.services.dependencies.pure);
-        switch (executionMode) {
-            case ServiceExecutionMode.FULL_INTERACTIVE: {
-                const data = this.createServiceRegistrationInput(graph, service);
-                data.origin = new V1_PureModelContextPointer(protocol);
-                input = data;
-                break;
-            }
-            case ServiceExecutionMode.SEMI_INTERACTIVE: {
-                const sdlcInfo = new V1_LegendSDLC(groupId, artifactId, version);
-                const pointer = new V1_PureModelContextPointer(protocol, sdlcInfo);
-                // data
-                const data = new V1_PureModelContextData();
-                data.origin = new V1_PureModelContextPointer(protocol);
-                const serviceProtocol = this.elementToProtocol(service);
-                // override the URL pattern if specified
-                if (options?.TEMPORARY__semiInteractiveOverridePattern) {
-                    serviceProtocol.pattern =
-                        options.TEMPORARY__semiInteractiveOverridePattern;
-                }
-                data.elements = [serviceProtocol];
-                // SDLC info
-                // TODO: We may need to add `runtime` pointers if the runtime defned in the service is a packageable runtime
-                // and not embedded.
-                const execution = service.execution;
-                if (execution instanceof PureSingleExecution) {
-                    if (execution.mapping) {
-                        sdlcInfo.packageableElementPointers = [
-                            new V1_PackageableElementPointer(PackageableElementPointerType.MAPPING, execution.mapping.value.path),
-                        ];
-                    }
-                }
-                else if (execution instanceof PureMultiExecution) {
-                    sdlcInfo.packageableElementPointers =
-                        execution.executionParameters.map((e) => new V1_PackageableElementPointer(PackageableElementPointerType.MAPPING, e.mapping.value.path));
-                }
-                else {
-                    throw new UnsupportedOperationError(`Can't register service with the specified execution`, execution);
-                }
-                // composite input
-                input = new V1_PureModelContextComposite(protocol, data, pointer);
-                break;
-            }
-            case ServiceExecutionMode.PROD: {
-                const sdlcInfo = new V1_LegendSDLC(groupId, artifactId, version);
-                const pointer = new V1_PureModelContextPointer(protocol, sdlcInfo);
-                sdlcInfo.packageableElementPointers = [
-                    new V1_PackageableElementPointer(PackageableElementPointerType.SERVICE, service.path),
-                ];
-                input = pointer;
-                break;
-            }
-            default: {
-                throw new UnsupportedOperationError(`Can't register service with execution mode '${executionMode}'`);
-            }
-        }
-        return V1_buildServiceRegistrationSuccess(service, await this.engine.registerService(input, server, executionMode, Boolean(options?.TEMPORARY__useStoreModel)));
-    }
-    async bulkServiceRegistration(services, graph, groupId, artifactId, version, server, executionMode, options) {
-        const serverServiceInfo = await this.engine.getServerServiceInfo();
-        const input = [];
-        const protocol = new V1_Protocol(V1_PureGraphManager.PURE_PROTOCOL_NAME, serverServiceInfo.services.dependencies.pure);
-        switch (executionMode) {
-            case ServiceExecutionMode.FULL_INTERACTIVE: {
-                const pmcp = this.createBulkServiceRegistrationInput(graph, services);
-                pmcp.forEach((data) => {
-                    data.origin = new V1_PureModelContextPointer(protocol);
-                    input.push(data);
-                });
-                break;
-            }
-            case ServiceExecutionMode.SEMI_INTERACTIVE: {
-                services.forEach((service) => {
-                    const sdlcInfo = new V1_LegendSDLC(groupId, artifactId, version);
-                    const pointer = new V1_PureModelContextPointer(protocol, sdlcInfo);
-                    // data
-                    const data = new V1_PureModelContextData();
-                    data.origin = new V1_PureModelContextPointer(protocol);
-                    const serviceProtocol = this.elementToProtocol(service);
-                    // override the URL pattern if specified
-                    if (options?.TEMPORARY__semiInteractiveOverridePattern) {
-                        serviceProtocol.pattern =
-                            options.TEMPORARY__semiInteractiveOverridePattern;
-                    }
-                    data.elements = [serviceProtocol];
-                    // SDLC info
-                    // TODO: We may need to add `runtime` pointers if the runtime defned in the service is a packageable runtime
-                    // and not embedded.
-                    const execution = service.execution;
-                    if (execution instanceof PureSingleExecution) {
-                        if (execution.mapping) {
-                            sdlcInfo.packageableElementPointers = [
-                                new V1_PackageableElementPointer(PackageableElementPointerType.MAPPING, execution.mapping.value.path),
-                            ];
-                        }
-                    }
-                    else if (execution instanceof PureMultiExecution) {
-                        sdlcInfo.packageableElementPointers =
-                            execution.executionParameters.map((e) => new V1_PackageableElementPointer(PackageableElementPointerType.MAPPING, e.mapping.value.path));
-                    }
-                    else {
-                        throw new UnsupportedOperationError(`Can't register service with the specified execution`, execution);
-                    }
-                    // composite input
-                    input.push(new V1_PureModelContextComposite(protocol, data, pointer));
-                });
-                break;
-            }
-            case ServiceExecutionMode.PROD: {
-                services.forEach((service) => {
-                    const sdlcInfo = new V1_LegendSDLC(groupId, artifactId, version);
-                    const pointer = new V1_PureModelContextPointer(protocol, sdlcInfo);
-                    const data = new V1_PackageableElementPointer(PackageableElementPointerType.SERVICE, service.path);
-                    sdlcInfo.packageableElementPointers.push(data);
-                    input.push(pointer);
-                });
-                break;
-            }
-            default: {
-                throw new UnsupportedOperationError(`Can't register service with execution mode '${executionMode}'`);
-            }
-        }
-        const results = (await Promise.all(input.map(async (graphData) => {
-            try {
-                const result = await this.engine.registerService(graphData, server, executionMode, Boolean(options?.TEMPORARY__useStoreModel));
-                if (result.status === 'success') {
-                    return new ServiceRegistrationSuccess(undefined, result.serverURL, result.pattern, result.serviceInstanceId);
-                }
-                return undefined;
-            }
-            catch (error) {
-                assertErrorThrown(error);
-                const result = new ServiceRegistrationFail(undefined, error.message);
-                if (graphData instanceof V1_PureModelContextData) {
-                    const servicePackage = getNullableFirstElement(graphData.elements.filter(filterByType(V1_Service)))?.package;
-                    const serviceName = getNullableFirstElement(graphData.elements.filter(filterByType(V1_Service)))?.name;
-                    const service = graph.getOwnService(V1_buildFullPath(servicePackage, serviceName));
-                    result.service = service;
-                }
-                return result;
-            }
-        }))).filter(isNonNullable);
-        return results;
-    }
-    async activateService(serviceUrl, serviceId) {
-        const serviceStorage = await this.engine.getServiceVersionInfo(serviceUrl, serviceId);
-        await this.engine.activateServiceGeneration(serviceUrl, serviceStorage.getGenerationId());
-    }
-    createServiceRegistrationInput = (graph, service) => {
-        const graphData = this.getFullGraphModelData(graph);
-        const prunedGraphData = new V1_PureModelContextData();
-        prunedGraphData.elements = graphData.elements.filter((element) => !(element instanceof V1_Service));
-        prunedGraphData.elements.push(this.elementToProtocol(service));
-        return prunedGraphData;
-    };
-    createBulkServiceRegistrationInput = (graph, services) => {
-        const graphData = this.getFullGraphModelData(graph);
-        const results = [];
-        services.forEach((service) => {
-            const prunedGraphData = new V1_PureModelContextData();
-            prunedGraphData.elements = graphData.elements.filter((element) => !(element instanceof V1_Service));
-            prunedGraphData.elements.push(this.elementToProtocol(service));
-            results.push(prunedGraphData);
-        });
-        return results;
-    };
-    // --------------------------------------------- Query ---------------------------------------------
-    async searchQueries(searchSpecification) {
-        return (await this.engine.searchQueries(V1_transformQuerySearchSpecification(searchSpecification))).map((protocol) => V1_buildLightQuery(protocol, this.engine.getCurrentUserId()));
-    }
-    async getLightQuery(queryId) {
-        return V1_buildLightQuery(await this.engine.getQuery(queryId), this.engine.getCurrentUserId());
-    }
-    // --------------------------------------------- Query ------------------------------------------------------
-    async getQuery(queryId, graph) {
-        return V1_buildQuery(await this.engine.getQuery(queryId), graph, this.engine.getCurrentUserId());
-    }
-    async getQueryInfo(queryId) {
-        const query = await this.engine.getQuery(queryId);
-        return {
-            name: query.name,
-            id: query.id,
-            versionId: query.versionId,
-            groupId: query.groupId,
-            artifactId: query.artifactId,
-            mapping: query.mapping,
-            runtime: query.runtime,
-            content: query.content,
-        };
-    }
-    async createQuery(query, graph) {
-        return V1_buildQuery(await this.engine.createQuery(V1_transformQuery(query)), graph, this.engine.getCurrentUserId());
-    }
-    async updateQuery(query, graph) {
-        return V1_buildQuery(await this.engine.updateQuery(V1_transformQuery(query)), graph, this.engine.getCurrentUserId());
-    }
-    async deleteQuery(queryId) {
-        await this.engine.deleteQuery(queryId);
-    }
-    // --------------------------------------------- Change Detection ---------------------------------------------
-    async buildHashesIndex(entities) {
-        const hashMap = new Map();
-        const pureModelContextData = new V1_PureModelContextData();
-        /**
-         * FIXME: to be deleted when most users have migrated to using full function signature as function name
-         * Currently, SDLC store many functions in legacy form (entity path does
-         * not contain full function signature). However, since they store function
-         * entity in text, when they parse the content to return JSON for entity
-         * content, the content is then updated to have proper `name` for function
-         * entities, this means that there's now a mismatch in the path constructed
-         * from entity content and the entity path, which is a contract that SDLC
-         * should maintain but currently not because of this change
-         * See https://github.com/finos/legend-sdlc/pull/515
-         *
-         * For that reason, during this migration, we want to respect entity path
-         * instead of the path constructed from entity content to properly
-         * reflect the renaming of function in local changes.
-         */
-        const TEMPORARY__entityPathIndex = new Map();
-        await V1_entitiesToPureModelContextData(entities, pureModelContextData, this.pluginManager.getPureProtocolProcessorPlugins(), TEMPORARY__entityPathIndex);
-        await Promise.all(pureModelContextData.elements.map((element) => promisify(() => hashMap.set(TEMPORARY__entityPathIndex.get(element.path)
-            ? guaranteeNonNullable(TEMPORARY__entityPathIndex.get(element.path))
-            : element.path, element.hashCode))));
-        return hashMap;
-    }
-    // ---------------------------------------- Analysis ----------------------------------------
-    buildMappingModelCoverageAnalysisInputContextData = (graph) => {
-        /**
-         * To lessen network load, we only include relevant part of the pure model context data here
-         *
-         * Graph data models can be classified based on dependency hieararchy:
-         * 1. Building blocks: models that all other models depend on: e.g. domain models, connections, etc.
-         * 2. Consumers: models that depends on other models: e.g. mapping, service, etc.
-         * 3. Unrelated: models that depends on nothing and vice versa: e.g. text
-         *
-         * For analyzing mapping, we choose to include some building blocks and mappings.
-         */
-        const graphData = this.getFullGraphModelData(graph);
-        const prunedGraphData = new V1_PureModelContextData();
-        const extraElements = this.pluginManager
-            .getPureProtocolProcessorPlugins()
-            .flatMap((element) => element.V1_getExtraMappingModelCoverageAnalysisInputCollectors?.() ??
-            [])
-            .flatMap((getter) => getter(graph, graphData));
-        prunedGraphData.elements = uniq(graphData.elements
-            .filter((element) => element instanceof V1_Class ||
-            element instanceof V1_Enumeration ||
-            element instanceof V1_Profile ||
-            element instanceof V1_Association ||
-            element instanceof V1_ConcreteFunctionDefinition ||
-            element instanceof V1_Measure ||
-            element instanceof V1_Store ||
-            element instanceof V1_Mapping)
-            .concat(extraElements));
-        return prunedGraphData;
-    };
-    async analyzeMappingModelCoverage(mapping, graph) {
-        const input = new V1_MappingModelCoverageAnalysisInput();
-        input.clientVersion = V1_PureGraphManager.DEV_PROTOCOL_VERSION;
-        input.mapping = mapping.path;
-        input.model = graph.origin
-            ? this.buildPureModelSDLCPointer(graph.origin, undefined)
-            : this.buildMappingModelCoverageAnalysisInputContextData(graph);
-        return V1_buildModelCoverageAnalysisResult(await this.engine.analyzeMappingModelCoverage(input), mapping);
-    }
-    buildMappingModelCoverageAnalysisResult(input, mapping) {
-        return V1_buildModelCoverageAnalysisResult(deserialize(V1_MappingModelCoverageAnalysisResult, input), mapping);
-    }
-    async surveyDatasets(mapping, runtime, query, graphData) {
-        const input = new V1_StoreEntitlementAnalysisInput();
-        input.clientVersion = V1_PureGraphManager.PROD_PROTOCOL_VERSION;
-        input.mapping = mapping.path;
-        input.runtime = runtime.path;
-        input.query = query
-            ? V1_transformRawLambda(query, new V1_GraphTransformerContextBuilder(this.pluginManager.getPureProtocolProcessorPlugins()).build())
-            : undefined;
-        if (graphData instanceof LiveGraphData) {
-            input.model = this.buildMappingModelCoverageAnalysisInputContextData(graphData.graph);
-        }
-        else if (graphData instanceof GraphDataWithOrigin) {
-            input.model = this.buildPureModelSDLCPointer(graphData.origin, V1_PureGraphManager.PROD_PROTOCOL_VERSION);
-        }
-        else {
-            throw new UnsupportedOperationError(`Can't process unsupported graph data`, graphData);
-        }
-        return (await this.engine.surveyDatasets(input, this.pluginManager.getPureProtocolProcessorPlugins())).map((dataset) => V1_buildDatasetSpecification(dataset, this.pluginManager.getPureProtocolProcessorPlugins()));
-    }
-    async checkEntitlements(mapping, runtime, query, graphData) {
-        const input = new V1_StoreEntitlementAnalysisInput();
-        input.clientVersion = V1_PureGraphManager.PROD_PROTOCOL_VERSION;
-        input.mapping = mapping.path;
-        input.runtime = runtime.path;
-        input.query = query
-            ? V1_transformRawLambda(query, new V1_GraphTransformerContextBuilder(this.pluginManager.getPureProtocolProcessorPlugins()).build())
-            : undefined;
-        if (graphData instanceof LiveGraphData) {
-            input.model = this.buildMappingModelCoverageAnalysisInputContextData(graphData.graph);
-        }
-        else if (graphData instanceof GraphDataWithOrigin) {
-            input.model = this.buildPureModelSDLCPointer(graphData.origin, V1_PureGraphManager.PROD_PROTOCOL_VERSION);
-        }
-        else {
-            throw new UnsupportedOperationError(`Can't process unsupported graph data`, graphData);
-        }
-        return (await this.engine.checkEntitlements(input, this.pluginManager.getPureProtocolProcessorPlugins())).map((report) => V1_buildDatasetEntitlementReport(report, this.pluginManager.getPureProtocolProcessorPlugins()));
-    }
-    // --------------------------------------------- Database ---------------------------------------------
-    async buildDatabase(input) {
-        const dbBuilderInput = new V1_DatabaseBuilderInput();
-        dbBuilderInput.connection = V1_transformRelationalDatabaseConnection(input.connection, new V1_GraphTransformerContextBuilder(this.pluginManager.getPureProtocolProcessorPlugins()).build());
-        const targetDatabase = new V1_TargetDatabase();
-        targetDatabase.package = input.targetDatabase.package;
-        targetDatabase.name = input.targetDatabase.name;
-        dbBuilderInput.targetDatabase = targetDatabase;
-        const config = new V1_DatabaseBuilderConfig();
-        config.maxTables = input.config.maxTables;
-        config.enrichTables = input.config.enrichTables;
-        config.enrichPrimaryKeys = input.config.enrichPrimaryKeys;
-        config.enrichColumns = input.config.enrichColumns;
-        config.patterns = input.config.patterns.map((storePattern) => {
-            const pattern = new V1_DatabasePattern();
-            pattern.schemaPattern = storePattern.schemaPattern;
-            pattern.tablePattern = storePattern.tablePattern;
-            pattern.escapeSchemaPattern = storePattern.escapeSchemaPattern;
-            pattern.escapeTablePattern = storePattern.escapeTablePattern;
-            return pattern;
-        });
-        dbBuilderInput.config = config;
-        return this.pureModelContextDataToEntities(await this.engine.buildDatabase(dbBuilderInput));
-    }
-    // --------------------------------------------- Utilities ---------------------------------------------
-    elementToEntity = (element, options) => {
-        const entity = this.elementProtocolToEntity(this.elementToProtocol(element));
-        if (options?.pruneSourceInformation) {
-            entity.content = pruneSourceInformation(entity.content);
-        }
-        return entity;
-    };
-    // --------------------------------------------- Shared ---------------------------------------------
-    buildPureModelSDLCPointer(origin, clientVersion) {
-        if (origin instanceof LegendSDLC) {
-            return new V1_PureModelContextPointer(clientVersion
-                ? new V1_Protocol(V1_PureGraphManager.PURE_PROTOCOL_NAME, clientVersion)
-                : undefined, new V1_LegendSDLC(origin.groupId, origin.artifactId, origin.versionId));
-        }
-        throw new UnsupportedOperationError('Unsupported graph origin');
-    }
-    /**
-     * This method helps indexing the graph from graph and dependencies' entities
-     * This will produce a _light_ graph with empty unprocesed elements, they are just indexed in the graph
-     * and the Pure model context data which can be used to further build the graph
-     *
-     * There are a few simple analytics we want to do on the graph which does not necessarily
-     * require us to build the full-graph, in fact, doing so would be too costly. In those scenarios,
-     * we need to build the _light_ graph, hence the existence of this utility method
-     *
-     * TODO?: do we need to account for system elements?
-     */
-    async indexLightGraph(graph, entities, dependencyEntitiesIndex, entityFilterFn, entityProcessorFn) {
-        const report = createGraphBuilderReport();
-        // build main graph builder input
-        const data = new V1_PureModelContextData();
-        await V1_entitiesToPureModelContextData(entities
-            .filter((entity) => {
-            // never exclude section index as it could be used for path resolution when building the graph later
-            if (entity.classifierPath === CORE_PURE_PATH.SECTION_INDEX) {
-                return true;
-            }
-            if (entityFilterFn) {
-                return entityFilterFn(entity);
-            }
-            return true;
-        })
-            .map((entity) => entityProcessorFn ? entityProcessorFn(entity) : entity), data, this.pluginManager.getPureProtocolProcessorPlugins());
-        const mainGraphBuilderInput = [
-            {
-                model: graph,
-                data: V1_indexPureModelContextData(report, data, this.graphBuilderExtensions),
-            },
-        ];
-        // build dependencies graph builder input
-        graph.dependencyManager.initialize(dependencyEntitiesIndex);
-        const dependencyGraphDataIndex = new Map();
-        await Promise.all(Array.from(dependencyEntitiesIndex.entries()).map(([dependencyKey, value]) => {
-            const projectModelData = new V1_PureModelContextData();
-            dependencyGraphDataIndex.set(dependencyKey, projectModelData);
-            return V1_entitiesToPureModelContextData(value.entities
-                .filter((entity) => {
-                // never exclude section index as it could be used for path resolution when building the graph later
-                if (entity.classifierPath === CORE_PURE_PATH.SECTION_INDEX) {
-                    return true;
-                }
-                if (entityFilterFn) {
-                    return entityFilterFn(entity);
-                }
-                return true;
-            })
-                .map((entity) => entityProcessorFn ? entityProcessorFn(entity) : entity), projectModelData, this.pluginManager.getPureProtocolProcessorPlugins());
-        }));
-        const dependencyGraphBuilderInput = Array.from(dependencyGraphDataIndex.entries()).map(([dependencyKey, dependencyData]) => ({
-            data: V1_indexPureModelContextData(report, dependencyData, this.graphBuilderExtensions),
-            model: graph.dependencyManager.getModel(dependencyKey),
-        }));
-        // index simplified graph
-        const graphBuilderInput = [
-            ...dependencyGraphBuilderInput,
-            ...mainGraphBuilderInput,
-        ];
-        await this.initializeAndIndexElements(graph, graphBuilderInput);
-        return graphBuilderInput;
-    }
-    getFullGraphModelContext(graph, clientVersion, options) {
-        // if options is given we will not use the origin if we want to keep source information
-        if (graph.origin && !options?.keepSourceInformation) {
-            return this.buildPureModelSDLCPointer(graph.origin, clientVersion);
-        }
-        return this.getFullGraphModelData(graph, options);
-    }
-    getFullGraphModelData(graph, options) {
-        const contextData1 = this.graphToPureModelContextData(graph, {
-            keepSourceInformation: options?.keepSourceInformation,
-        });
-        const contextData2 = this.getGraphCompileContext(graph);
-        contextData1.elements = [
-            ...contextData1.elements,
-            ...contextData2.elements,
-        ];
-        return contextData1;
-    }
-    elementProtocolToEntity = (elementProtocol) => ({
-        path: this.getElementPath(elementProtocol),
-        content: V1_serializePackageableElement(elementProtocol, this.pluginManager.getPureProtocolProcessorPlugins()),
-        classifierPath: this.getElementClassiferPath(elementProtocol),
-    });
-    pureModelContextDataToEntities = (graphProtocol) => graphProtocol.elements.map((element) => this.elementProtocolToEntity(element));
-    async entitiesToPureModelContextData(entities) {
-        const graphData = new V1_PureModelContextData();
-        await V1_entitiesToPureModelContextData(entities, graphData, this.pluginManager.getPureProtocolProcessorPlugins());
-        return graphData;
-    }
-    elementToProtocol = (element, options) => V1_transformPackageableElement(element, this.pluginManager.getPureProtocolProcessorPlugins(), new V1_GraphTransformerContextBuilder(this.pluginManager.getPureProtocolProcessorPlugins())
-        .withKeepSourceInformationFlag(Boolean(options?.keepSourceInformation))
-        .build());
-    getElementPath = (elementProtocol) => `${elementProtocol.package}${ENTITY_PATH_DELIMITER}${elementProtocol.name}`;
-    getElementClassiferPath = (protocol) => {
-        if (protocol instanceof V1_Association) {
-            return CORE_PURE_PATH.ASSOCIATION;
-        }
-        else if (protocol instanceof V1_Class) {
-            return CORE_PURE_PATH.CLASS;
-        }
-        else if (protocol instanceof V1_Enumeration) {
-            return CORE_PURE_PATH.ENUMERATION;
-        }
-        else if (protocol instanceof V1_ConcreteFunctionDefinition) {
-            return CORE_PURE_PATH.FUNCTION;
-        }
-        else if (protocol instanceof V1_Profile) {
-            return CORE_PURE_PATH.PROFILE;
-        }
-        else if (protocol instanceof V1_Measure) {
-            return CORE_PURE_PATH.MEASURE;
-        }
-        else if (protocol instanceof V1_Mapping) {
-            return CORE_PURE_PATH.MAPPING;
-        }
-        else if (protocol instanceof V1_PackageableConnection) {
-            return CORE_PURE_PATH.CONNECTION;
-        }
-        else if (protocol instanceof V1_PackageableRuntime) {
-            return CORE_PURE_PATH.RUNTIME;
-        }
-        else if (protocol instanceof V1_SectionIndex) {
-            return CORE_PURE_PATH.SECTION_INDEX;
-        }
-        else if (protocol instanceof V1_FlatData) {
-            return CORE_PURE_PATH.FLAT_DATA;
-        }
-        else if (protocol instanceof V1_Database) {
-            return CORE_PURE_PATH.DATABASE;
-        }
-        else if (protocol instanceof V1_ExecutionEnvironmentInstance) {
-            return CORE_PURE_PATH.EXECUTION_ENVIRONMENT;
-        }
-        else if (protocol instanceof V1_Service) {
-            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;
-        }
-        const extraElementProtocolClassifierPathGetters = this.pluginManager
-            .getPureProtocolProcessorPlugins()
-            .flatMap((plugin) => plugin.V1_getExtraElementClassifierPathGetters?.() ?? []);
-        for (const classifierPathGetter of extraElementProtocolClassifierPathGetters) {
-            const classifierPath = classifierPathGetter(protocol);
-            if (classifierPath) {
-                return classifierPath;
-            }
-        }
-        throw new UnsupportedOperationError(`Can't get classifier path for element '${protocol.path}': no compatible classifier path getter available from plugins`);
-    };
-    graphToPureModelContextData = (graph, options) => {
-        const startTime = Date.now();
-        const graphData = new V1_PureModelContextData();
-        graphData.elements = graph.allOwnElements.map((element) => this.elementToProtocol(element, {
-            keepSourceInformation: options?.keepSourceInformation,
-        }));
-        this.logService.info(LogEvent.create(GRAPH_MANAGER_EVENT.TRANSFORM_GRAPH_META_MODEL_TO_PROTOCOL__SUCCESS), Date.now() - startTime, 'ms');
-        return graphData;
-    };
-    getGraphCompileContext = (graph) => {
-        const startTime = Date.now();
-        const graphData = new V1_PureModelContextData();
-        const dependencyManager = graph.dependencyManager;
-        const generatedModel = graph.generationModel;
-        graphData.elements = [
-            ...dependencyManager.allOwnElements,
-            ...generatedModel.allOwnElements,
-        ].map((element) => this.elementToProtocol(element));
-        this.logService.info(LogEvent.create(GRAPH_MANAGER_EVENT.COLLECT_GRAPH_COMPILE_CONTEXT__SUCCESS), Date.now() - startTime, 'ms');
-        return graphData;
-    };
-}
-export { V1_PureGraphManager };
-//# sourceMappingURL=V1_PureGraphManager.js.map