@finos/legend-application-studio 22.6.0 → 23.0.1

package/lib/stores/editor-state/element-editor-state/service/ServiceExecutionState.js

@@ -1,672 +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 { observable, action, flow, makeObservable, flowResult } from 'mobx';
-import { ActionState, assertErrorThrown, LogEvent, stringifyLosslessJSON, UnsupportedOperationError, filterByType, guaranteeNonNullable, StopWatch, } from '@finos/legend-shared';
-import { decorateRuntimeWithNewMapping, RuntimeEditorState, } from '../../../editor-state/element-editor-state/RuntimeEditorState.js';
-import { DEFAULT_TYPEAHEAD_SEARCH_LIMIT, DEFAULT_TYPEAHEAD_SEARCH_MINIMUM_SEARCH_LENGTH, ExecutionPlanState, generateExtensionUrlPattern, generatePath, TAB_SIZE, } from '@finos/legend-application';
-import { PureSingleExecution, PureMultiExecution, KeyedExecutionParameter, GRAPH_MANAGER_EVENT, RawLambda, EngineRuntime, RuntimePointer, PackageableElementExplicitReference, buildSourceInformationSourceId, QueryProjectCoordinates, QuerySearchSpecification, buildLambdaVariableExpressions, observe_ValueSpecification, VariableExpression, stub_PackageableRuntime, stub_Mapping, reportGraphAnalytics, } from '@finos/legend-graph';
-import { parseGACoordinates, generateGAVCoordinates, } from '@finos/legend-storage';
-import { runtime_addMapping } from '../../../shared/modifier/DSL_Mapping_GraphModifierHelper.js';
-import { keyedExecutionParameter_setKey, pureExecution_setFunction, pureMultiExecution_addExecutionParameter, pureMultiExecution_deleteExecutionParameter, pureMultiExecution_setExecutionKey, pureSingleExecution_setMapping, pureSingleExecution_setRuntime, service_setExecution, } from '../../../shared/modifier/DSL_Service_GraphModifierHelper.js';
-import { buildExecutionParameterValues, getExecutionQueryFromRawLambda, LambdaEditorState, LambdaParametersState, LambdaParameterState, PARAMETER_SUBMIT_ACTION, QueryBuilderTelemetry, QUERY_BUILDER_EVENT, } from '@finos/legend-query-builder';
-import { LEGEND_STUDIO_APPLICATION_NAVIGATION_CONTEXT_KEY } from '../../../LegendStudioApplicationNavigationContext.js';
-var DSL_SERVICE_PATH_PARAM_TOKEN;
-(function (DSL_SERVICE_PATH_PARAM_TOKEN) {
-    DSL_SERVICE_PATH_PARAM_TOKEN["PROJECT_ID"] = "projectId";
-    DSL_SERVICE_PATH_PARAM_TOKEN["GROUP_WORKSPACE_ID"] = "groupWorkspaceId";
-    DSL_SERVICE_PATH_PARAM_TOKEN["SERVICE_PATH"] = "servicePath";
-})(DSL_SERVICE_PATH_PARAM_TOKEN || (DSL_SERVICE_PATH_PARAM_TOKEN = {}));
-var LEGEND_QUERY_PATH_PARAM_TOKEN;
-(function (LEGEND_QUERY_PATH_PARAM_TOKEN) {
-    LEGEND_QUERY_PATH_PARAM_TOKEN["GAV"] = "gav";
-    LEGEND_QUERY_PATH_PARAM_TOKEN["SERVICE_PATH"] = "servicePath";
-})(LEGEND_QUERY_PATH_PARAM_TOKEN || (LEGEND_QUERY_PATH_PARAM_TOKEN = {}));
-const QUERY_ROUTE_PATTERN = Object.freeze({
-    CREATE_FROM_SERVICE_QUERY: `/create-from-service/:${LEGEND_QUERY_PATH_PARAM_TOKEN.GAV}/:${LEGEND_QUERY_PATH_PARAM_TOKEN.SERVICE_PATH}`,
-    UPDATE_PROJECT_SERVICE_QUERY: `/update-project-service-query/:${DSL_SERVICE_PATH_PARAM_TOKEN.PROJECT_ID}/:${DSL_SERVICE_PATH_PARAM_TOKEN.GROUP_WORKSPACE_ID}/:${DSL_SERVICE_PATH_PARAM_TOKEN.SERVICE_PATH}`,
-});
-export class ServiceExecutionParameterState extends LambdaParametersState {
-    executionState;
-    constructor(executionState) {
-        super();
-        makeObservable(this, {
-            parameterValuesEditorState: observable,
-            parameterStates: observable,
-            addParameter: action,
-            removeParameter: action,
-            openModal: action,
-            build: action,
-            setParameters: action,
-        });
-        this.executionState = executionState;
-    }
-    openModal(query) {
-        this.parameterStates = this.build(query);
-        this.parameterValuesEditorState.open(() => flowResult(this.executionState.runQuery()).catch(this.executionState.editorStore.applicationStore.alertUnhandledError), PARAMETER_SUBMIT_ACTION.RUN);
-    }
-    build(query) {
-        const parameters = buildLambdaVariableExpressions(query, this.executionState.editorStore.graphManagerState)
-            .map((p) => observe_ValueSpecification(p, this.executionState.editorStore.changeDetectionState.observerContext))
-            .filter(filterByType(VariableExpression));
-        const states = parameters.map((p) => {
-            const parmeterState = new LambdaParameterState(p, this.executionState.editorStore.changeDetectionState.observerContext, this.executionState.editorStore.graphManagerState.graph);
-            parmeterState.mockParameterValue();
-            return parmeterState;
-        });
-        return states;
-    }
-}
-export class ServiceExecutionState {
-    editorStore;
-    serviceEditorState;
-    execution;
-    constructor(editorStore, serviceEditorState, execution) {
-        makeObservable(this, {
-            execution: observable,
-        });
-        this.editorStore = editorStore;
-        this.execution = execution;
-        this.serviceEditorState = serviceEditorState;
-    }
-}
-export class UnsupportedServiceExecutionState extends ServiceExecutionState {
-    get serviceExecutionParameters() {
-        return undefined;
-    }
-}
-export class ServicePureExecutionQueryState extends LambdaEditorState {
-    editorStore;
-    execution;
-    isInitializingLambda = false;
-    openQueryImporter = false;
-    queries = [];
-    selectedQueryInfo;
-    loadQueriesState = ActionState.create();
-    loadQueryInfoState = ActionState.create();
-    importQueryState = ActionState.create();
-    constructor(editorStore, execution) {
-        super('', '');
-        makeObservable(this, {
-            execution: observable,
-            isInitializingLambda: observable,
-            openQueryImporter: observable,
-            queries: observable,
-            selectedQueryInfo: observable,
-            setOpenQueryImporter: action,
-            setIsInitializingLambda: action,
-            setLambda: action,
-            updateLamba: flow,
-            loadQueries: flow,
-            setSelectedQueryInfo: flow,
-            importQuery: flow,
-        });
-        this.editorStore = editorStore;
-        this.execution = execution;
-    }
-    get lambdaId() {
-        return buildSourceInformationSourceId([
-            this.execution._OWNER.path,
-            'execution',
-        ]);
-    }
-    get query() {
-        return this.execution.func;
-    }
-    setIsInitializingLambda(val) {
-        this.isInitializingLambda = val;
-    }
-    setLambda(val) {
-        pureExecution_setFunction(this.execution, val);
-    }
-    setOpenQueryImporter(val) {
-        this.openQueryImporter = val;
-    }
-    *setSelectedQueryInfo(query) {
-        if (query) {
-            try {
-                this.loadQueryInfoState.inProgress();
-                const content = (yield this.editorStore.graphManagerState.graphManager.prettyLambdaContent((yield this.editorStore.graphManagerState.graphManager.getQueryInfo(query.id)).content));
-                this.selectedQueryInfo = {
-                    query,
-                    content,
-                };
-            }
-            catch (error) {
-                assertErrorThrown(error);
-                this.editorStore.applicationStore.notificationService.notifyError(error);
-            }
-            finally {
-                this.loadQueryInfoState.reset();
-            }
-        }
-        else {
-            this.selectedQueryInfo = undefined;
-        }
-    }
-    *importQuery() {
-        if (this.selectedQueryInfo) {
-            try {
-                this.importQueryState.inProgress();
-                const lambda = (yield this.editorStore.graphManagerState.graphManager.pureCodeToLambda(this.selectedQueryInfo.content));
-                yield flowResult(this.updateLamba(lambda));
-            }
-            catch (error) {
-                assertErrorThrown(error);
-                this.editorStore.applicationStore.notificationService.notifyError(error);
-            }
-            finally {
-                this.setOpenQueryImporter(false);
-                this.importQueryState.reset();
-            }
-        }
-    }
-    *loadQueries(searchText) {
-        const isValidSearchString = searchText.length >= DEFAULT_TYPEAHEAD_SEARCH_MINIMUM_SEARCH_LENGTH;
-        this.loadQueriesState.inProgress();
-        try {
-            const searchSpecification = new QuerySearchSpecification();
-            const currentProjectCoordinates = new QueryProjectCoordinates();
-            currentProjectCoordinates.groupId =
-                this.editorStore.projectConfigurationEditorState.currentProjectConfiguration.groupId;
-            currentProjectCoordinates.artifactId =
-                this.editorStore.projectConfigurationEditorState.currentProjectConfiguration.artifactId;
-            searchSpecification.searchTerm = isValidSearchString
-                ? searchText
-                : undefined;
-            searchSpecification.limit = DEFAULT_TYPEAHEAD_SEARCH_LIMIT;
-            searchSpecification.projectCoordinates = [
-                // either get queries for the current project
-                currentProjectCoordinates,
-                // or any of its dependencies
-                ...Array.from((yield this.editorStore.graphState.getIndexedDependencyEntities()).keys()).map((coordinatesInText) => {
-                    const { groupId, artifactId } = parseGACoordinates(coordinatesInText);
-                    const coordinates = new QueryProjectCoordinates();
-                    coordinates.groupId = groupId;
-                    coordinates.artifactId = artifactId;
-                    return coordinates;
-                }),
-            ];
-            this.queries =
-                (yield this.editorStore.graphManagerState.graphManager.searchQueries(searchSpecification));
-            this.loadQueriesState.pass();
-        }
-        catch (error) {
-            assertErrorThrown(error);
-            this.loadQueriesState.fail();
-            this.editorStore.applicationStore.notificationService.notifyError(error);
-        }
-    }
-    *updateLamba(val) {
-        this.setLambda(val);
-        yield flowResult(this.convertLambdaObjectToGrammarString(true));
-    }
-    *convertLambdaObjectToGrammarString(pretty) {
-        if (this.execution.func.body) {
-            try {
-                const lambdas = new Map();
-                lambdas.set(this.lambdaId, new RawLambda(this.execution.func.parameters, this.execution.func.body));
-                const isolatedLambdas = (yield this.editorStore.graphManagerState.graphManager.lambdasToPureCode(lambdas, pretty));
-                const grammarText = isolatedLambdas.get(this.lambdaId);
-                this.setLambdaString(grammarText !== undefined
-                    ? this.extractLambdaString(grammarText)
-                    : '');
-                this.clearErrors();
-            }
-            catch (error) {
-                assertErrorThrown(error);
-                this.editorStore.applicationStore.logService.error(LogEvent.create(GRAPH_MANAGER_EVENT.PARSING_FAILURE), error);
-            }
-        }
-        else {
-            this.clearErrors();
-            this.setLambdaString('');
-        }
-    }
-    // NOTE: since we don't allow edition in text mode, we don't need to implement this
-    *convertLambdaGrammarStringToObject() {
-        throw new UnsupportedOperationError();
-    }
-}
-export class ServiceExecutionContextState {
-    executionState;
-    constructor(executionState) {
-        this.executionState = executionState;
-    }
-}
-export class SingleExecutionContextState extends ServiceExecutionContextState {
-    constructor(executionState) {
-        super(executionState);
-        makeObservable(this, {
-            setMapping: action,
-            setRuntime: action,
-        });
-        this.executionState = executionState;
-    }
-    setMapping(value) {
-        pureSingleExecution_setMapping(this.executionState.execution, value, this.executionState.editorStore.changeDetectionState.observerContext);
-    }
-    setRuntime(value) {
-        pureSingleExecution_setRuntime(this.executionState.execution, value, this.executionState.editorStore.changeDetectionState.observerContext);
-    }
-    get executionContext() {
-        return {
-            mapping: guaranteeNonNullable(this.executionState.execution.mapping),
-            runtime: guaranteeNonNullable(this.executionState.execution.runtime),
-        };
-    }
-}
-export class KeyedExecutionContextState extends ServiceExecutionContextState {
-    keyedExecutionParameter;
-    constructor(keyedExecutionParameter, executionState) {
-        super(executionState);
-        makeObservable(this, {
-            setMapping: action,
-            setRuntime: action,
-        });
-        this.keyedExecutionParameter = keyedExecutionParameter;
-    }
-    setMapping(value) {
-        pureSingleExecution_setMapping(this.keyedExecutionParameter, value, this.executionState.editorStore.changeDetectionState.observerContext);
-    }
-    setRuntime(value) {
-        pureSingleExecution_setRuntime(this.keyedExecutionParameter, value, this.executionState.editorStore.changeDetectionState.observerContext);
-    }
-    get executionContext() {
-        return this.keyedExecutionParameter;
-    }
-}
-export class ServicePureExecutionState extends ServiceExecutionState {
-    queryState;
-    selectedExecutionContextState;
-    runtimeEditorState;
-    isRunningQuery = false;
-    isGeneratingPlan = false;
-    isOpeningQueryEditor = false;
-    executionResultText; // NOTE: stored as lossless JSON string
-    executionPlanState;
-    parameterState;
-    showChangeExecModal = false;
-    queryRunPromise = undefined;
-    constructor(editorStore, serviceEditorState, execution) {
-        super(editorStore, serviceEditorState, execution);
-        this.execution = execution;
-        this.queryState = new ServicePureExecutionQueryState(this.editorStore, execution);
-        this.executionPlanState = new ExecutionPlanState(this.editorStore.applicationStore, this.editorStore.graphManagerState);
-        this.parameterState = new ServiceExecutionParameterState(this);
-    }
-    isChangeExecutionDisabled() {
-        return false;
-    }
-    setIsRunningQuery(val) {
-        this.isRunningQuery = val;
-    }
-    setShowChangeExecModal(val) {
-        this.showChangeExecModal = val;
-    }
-    setOpeningQueryEditor(val) {
-        this.isOpeningQueryEditor = val;
-    }
-    setExecutionResultText = (executionResult) => {
-        this.executionResultText = executionResult;
-    };
-    setQueryState = (queryState) => {
-        this.queryState = queryState;
-    };
-    setQueryRunPromise = (promise) => {
-        this.queryRunPromise = promise;
-    };
-    *generatePlan(debug) {
-        if (this.isGeneratingPlan) {
-            return;
-        }
-        try {
-            const query = this.queryState.query;
-            this.isGeneratingPlan = true;
-            let rawPlan;
-            const stopWatch = new StopWatch();
-            const report = reportGraphAnalytics(this.editorStore.graphManagerState.graph);
-            if (debug) {
-                QueryBuilderTelemetry.logEvent_ExecutionPlanDebugLaunched(this.editorStore.applicationStore.telemetryService, {
-                    applicationContext: LEGEND_STUDIO_APPLICATION_NAVIGATION_CONTEXT_KEY.SERVICE_EDITOR_EXECUTION,
-                });
-                const debugResult = (yield this.editorStore.graphManagerState.graphManager.debugExecutionPlanGeneration(query, this.selectedExecutionContextState?.executionContext.mapping.value, this.selectedExecutionContextState?.executionContext.runtime, this.editorStore.graphManagerState.graph, report));
-                rawPlan = debugResult.plan;
-                this.executionPlanState.setDebugText(debugResult.debug);
-            }
-            else {
-                QueryBuilderTelemetry.logEvent_ExecutionPlanGenerationLaunched(this.editorStore.applicationStore.telemetryService, {
-                    applicationContext: LEGEND_STUDIO_APPLICATION_NAVIGATION_CONTEXT_KEY.SERVICE_EDITOR_EXECUTION,
-                });
-                rawPlan =
-                    (yield this.editorStore.graphManagerState.graphManager.generateExecutionPlan(query, this.selectedExecutionContextState?.executionContext.mapping.value, this.selectedExecutionContextState?.executionContext.runtime, this.editorStore.graphManagerState.graph, report));
-            }
-            stopWatch.record();
-            try {
-                this.executionPlanState.setRawPlan(rawPlan);
-                const plan = this.editorStore.graphManagerState.graphManager.buildExecutionPlan(rawPlan, this.editorStore.graphManagerState.graph);
-                this.executionPlanState.setPlan(plan);
-            }
-            catch {
-                // do nothing
-            }
-            stopWatch.record(QUERY_BUILDER_EVENT.BUILD_EXECUTION_PLAN__SUCCESS);
-            // report
-            report.timings =
-                this.editorStore.applicationStore.timeService.finalizeTimingsRecord(stopWatch, report.timings);
-            if (debug) {
-                QueryBuilderTelemetry.logEvent_ExecutionPlanDebugSucceeded(this.editorStore.applicationStore.telemetryService, report);
-            }
-            else {
-                QueryBuilderTelemetry.logEvent_ExecutionPlanGenerationSucceeded(this.editorStore.applicationStore.telemetryService, report);
-            }
-        }
-        catch (error) {
-            assertErrorThrown(error);
-            this.editorStore.applicationStore.logService.error(LogEvent.create(GRAPH_MANAGER_EVENT.EXECUTION_FAILURE), error);
-            this.editorStore.applicationStore.notificationService.notifyError(error);
-        }
-        finally {
-            this.isGeneratingPlan = false;
-        }
-    }
-    *handleRunQuery() {
-        if (this.isRunningQuery) {
-            return;
-        }
-        const query = this.queryState.query;
-        const parameters = (query.parameters ?? []);
-        if (parameters.length) {
-            this.parameterState.openModal(query);
-        }
-        else {
-            this.runQuery();
-        }
-    }
-    *runQuery() {
-        if (this.isRunningQuery) {
-            return;
-        }
-        QueryBuilderTelemetry.logEvent_QueryRunLaunched(this.editorStore.applicationStore.telemetryService, {
-            applicationContext: LEGEND_STUDIO_APPLICATION_NAVIGATION_CONTEXT_KEY.SERVICE_EDITOR_EXECUTION,
-        });
-        try {
-            this.isRunningQuery = true;
-            const stopWatch = new StopWatch();
-            const report = reportGraphAnalytics(this.editorStore.graphManagerState.graph);
-            const promise = this.editorStore.graphManagerState.graphManager.runQuery(this.getExecutionQuery(), this.selectedExecutionContextState?.executionContext.mapping.value, this.selectedExecutionContextState?.executionContext.runtime, this.editorStore.graphManagerState.graph, {
-                useLosslessParse: true,
-                parameterValues: buildExecutionParameterValues(this.parameterState.parameterStates, this.editorStore.graphManagerState),
-            }, report);
-            this.setQueryRunPromise(promise);
-            const result = (yield promise);
-            if (this.queryRunPromise === promise) {
-                this.setExecutionResultText(stringifyLosslessJSON(result, undefined, TAB_SIZE));
-                this.parameterState.setParameters([]);
-                // report
-                report.timings =
-                    this.editorStore.applicationStore.timeService.finalizeTimingsRecord(stopWatch, report.timings);
-                QueryBuilderTelemetry.logEvent_QueryRunSucceeded(this.editorStore.applicationStore.telemetryService, report);
-            }
-        }
-        catch (error) {
-            assertErrorThrown(error);
-            this.editorStore.applicationStore.logService.error(LogEvent.create(GRAPH_MANAGER_EVENT.EXECUTION_FAILURE), error);
-            this.editorStore.applicationStore.notificationService.notifyError(error);
-        }
-        finally {
-            this.isRunningQuery = false;
-        }
-    }
-    getExecutionQuery() {
-        return getExecutionQueryFromRawLambda(this.queryState.query, this.parameterState.parameterStates, this.editorStore.graphManagerState);
-    }
-    get serviceExecutionParameters() {
-        if (!this.selectedExecutionContextState || this.isRunningQuery) {
-            return undefined;
-        }
-        const query = this.queryState.query;
-        return {
-            query,
-            mapping: this.selectedExecutionContextState.executionContext.mapping.value,
-            runtime: this.selectedExecutionContextState.executionContext.runtime,
-        };
-    }
-    closeRuntimeEditor() {
-        this.runtimeEditorState = undefined;
-    }
-    openRuntimeEditor() {
-        if (this.selectedExecutionContextState &&
-            !(this.selectedExecutionContextState.executionContext.runtime instanceof
-                RuntimePointer)) {
-            this.runtimeEditorState = new RuntimeEditorState(this.editorStore, this.selectedExecutionContextState.executionContext.runtime, true);
-        }
-    }
-    useCustomRuntime() {
-        const customRuntime = new EngineRuntime();
-        guaranteeNonNullable(this.selectedExecutionContextState);
-        const executionState = this
-            .selectedExecutionContextState;
-        runtime_addMapping(customRuntime, PackageableElementExplicitReference.create(executionState.executionContext.mapping.value));
-        decorateRuntimeWithNewMapping(customRuntime, executionState.executionContext.mapping.value, this.editorStore);
-        executionState.setRuntime(customRuntime);
-    }
-    autoSelectRuntimeOnMappingChange(mapping) {
-        if (this.selectedExecutionContextState) {
-            const runtimes = this.editorStore.graphManagerState.graph.ownRuntimes.filter((runtime) => runtime.runtimeValue.mappings.map((m) => m.value).includes(mapping));
-            if (runtimes.length) {
-                this.selectedExecutionContextState.setRuntime(runtimes[0].runtimeValue);
-            }
-            else {
-                this.useCustomRuntime();
-            }
-        }
-    }
-    updateExecutionQuery() {
-        pureExecution_setFunction(this.execution, this.queryState.query);
-    }
-    generateServiceQueryCreatorRoute = (baseUrl, groupId, artifactId, versionId, servicePath) => baseUrl +
-        generatePath(QUERY_ROUTE_PATTERN.CREATE_FROM_SERVICE_QUERY, {
-            [LEGEND_QUERY_PATH_PARAM_TOKEN.GAV]: generateGAVCoordinates(groupId, artifactId, versionId),
-            [LEGEND_QUERY_PATH_PARAM_TOKEN.SERVICE_PATH]: servicePath,
-        });
-    generateProjectServiceQueryUpdaterRoute = (projectId, groupWorkspaceId, servicePath) => generatePath(generateExtensionUrlPattern(QUERY_ROUTE_PATTERN.UPDATE_PROJECT_SERVICE_QUERY), {
-        [DSL_SERVICE_PATH_PARAM_TOKEN.PROJECT_ID]: projectId,
-        [DSL_SERVICE_PATH_PARAM_TOKEN.GROUP_WORKSPACE_ID]: groupWorkspaceId,
-        [DSL_SERVICE_PATH_PARAM_TOKEN.SERVICE_PATH]: servicePath,
-    });
-}
-export class InlineServicePureExecutionState extends ServicePureExecutionState {
-    constructor(editorStore, serviceEditorState, execution) {
-        super(editorStore, serviceEditorState, execution);
-        makeObservable(this, {
-            queryState: observable,
-            isRunningQuery: observable,
-            isGeneratingPlan: observable,
-            isOpeningQueryEditor: observable,
-            executionResultText: observable,
-            executionPlanState: observable,
-            showChangeExecModal: observable,
-            parameterState: observable,
-            setExecutionResultText: action,
-            setQueryState: action,
-            updateExecutionQuery: action,
-            setOpeningQueryEditor: action,
-            generatePlan: flow,
-            handleRunQuery: flow,
-            runQuery: flow,
-        });
-        this.selectedExecutionContextState =
-            this.getInitiallySelectedExecutionContextState();
-    }
-    changeExecution() {
-        throw new Error('Method not implemented.');
-    }
-    getInitiallySelectedExecutionContextState() {
-        return undefined;
-    }
-}
-export class SingleServicePureExecutionState extends ServicePureExecutionState {
-    multiExecutionKey = 'key';
-    constructor(editorStore, serviceEditorState, execution) {
-        super(editorStore, serviceEditorState, execution);
-        makeObservable(this, {
-            queryState: observable,
-            getInitiallySelectedExecutionContextState: observable,
-            selectedExecutionContextState: observable,
-            runtimeEditorState: observable,
-            isRunningQuery: observable,
-            isGeneratingPlan: observable,
-            isOpeningQueryEditor: observable,
-            executionResultText: observable,
-            executionPlanState: observable,
-            showChangeExecModal: observable,
-            parameterState: observable,
-            multiExecutionKey: observable,
-            setExecutionResultText: action,
-            closeRuntimeEditor: action,
-            openRuntimeEditor: action,
-            useCustomRuntime: action,
-            setQueryState: action,
-            autoSelectRuntimeOnMappingChange: action,
-            updateExecutionQuery: action,
-            setOpeningQueryEditor: action,
-            changeExecution: action,
-            setMultiExecutionKey: action,
-            setShowChangeExecModal: action,
-            setIsRunningQuery: action,
-            generatePlan: flow,
-            handleRunQuery: flow,
-            runQuery: flow,
-        });
-        this.selectedExecutionContextState =
-            this.getInitiallySelectedExecutionContextState();
-    }
-    isChangeExecutionDisabled() {
-        return this.multiExecutionKey === '';
-    }
-    getInitiallySelectedExecutionContextState() {
-        return new SingleExecutionContextState(this);
-    }
-    setMultiExecutionKey(val) {
-        this.multiExecutionKey = val;
-    }
-    changeExecution() {
-        if (this.execution.mapping && this.execution.runtime) {
-            const _execution = new PureMultiExecution(this.multiExecutionKey, this.execution.func, this.serviceEditorState.service);
-            const _parameter = new KeyedExecutionParameter(`execContext_1`, this.execution.mapping, this.execution.runtime);
-            _execution.executionParameters = [_parameter];
-            service_setExecution(this.serviceEditorState.service, _execution, this.editorStore.changeDetectionState.observerContext);
-            this.serviceEditorState.resetExecutionState();
-        }
-    }
-}
-export class MultiServicePureExecutionState extends ServicePureExecutionState {
-    newKeyParameterModal = false;
-    renameKey;
-    singleExecutionKey;
-    constructor(editorStore, serviceEditorState, execution) {
-        super(editorStore, serviceEditorState, execution);
-        makeObservable(this, {
-            queryState: observable,
-            selectedExecutionContextState: observable,
-            runtimeEditorState: observable,
-            isRunningQuery: observable,
-            isGeneratingPlan: observable,
-            isOpeningQueryEditor: observable,
-            executionResultText: observable,
-            executionPlanState: observable,
-            newKeyParameterModal: observable,
-            renameKey: observable,
-            singleExecutionKey: observable,
-            showChangeExecModal: observable,
-            setExecutionResultText: action,
-            closeRuntimeEditor: action,
-            openRuntimeEditor: action,
-            useCustomRuntime: action,
-            setQueryState: action,
-            autoSelectRuntimeOnMappingChange: action,
-            updateExecutionQuery: action,
-            setOpeningQueryEditor: action,
-            deleteKeyExecutionParameter: action,
-            setNewKeyParameterModal: action,
-            changeKeyedExecutionParameter: action,
-            setRenameKey: action,
-            addExecutionParameter: action,
-            setExecutionKey: action,
-            changeKeyValue: action,
-            setSingleExecutionKey: action,
-            setShowChangeExecModal: action,
-            setIsRunningQuery: action,
-            changeExecution: action,
-            generatePlan: flow,
-            handleRunQuery: flow,
-            runQuery: flow,
-        });
-        this.execution = execution;
-        this.selectedExecutionContextState =
-            this.getInitiallySelectedExecutionContextState();
-        this.queryState = new ServicePureExecutionQueryState(this.editorStore, execution);
-        this.executionPlanState = new ExecutionPlanState(this.editorStore.applicationStore, this.editorStore.graphManagerState);
-    }
-    setSingleExecutionKey(val) {
-        this.singleExecutionKey = val;
-    }
-    changeExecution() {
-        const mappingExecution = this.singleExecutionKey;
-        // stub
-        const _mapping = mappingExecution?.mapping.value ?? stub_Mapping();
-        const mapping = PackageableElementExplicitReference.create(_mapping);
-        const runtime = mappingExecution?.runtime ?? stub_PackageableRuntime();
-        const _execution = new PureSingleExecution(this.execution.func, this.serviceEditorState.service, mapping, runtime);
-        service_setExecution(this.serviceEditorState.service, _execution, this.editorStore.changeDetectionState.observerContext);
-        this.serviceEditorState.resetExecutionState();
-    }
-    setRenameKey(key) {
-        this.renameKey = key;
-    }
-    setNewKeyParameterModal(val) {
-        this.newKeyParameterModal = val;
-    }
-    setExecutionKey(val) {
-        pureMultiExecution_setExecutionKey(this.execution, val);
-    }
-    getInitiallySelectedExecutionContextState() {
-        const parameter = this.execution.executionParameters[0];
-        return parameter
-            ? new KeyedExecutionContextState(parameter, this)
-            : undefined;
-    }
-    changeKeyedExecutionParameter(value) {
-        this.selectedExecutionContextState = new KeyedExecutionContextState(value, this);
-    }
-    deleteKeyExecutionParameter(value) {
-        pureMultiExecution_deleteExecutionParameter(this.execution, value);
-        if (value === this.selectedExecutionContextState?.executionContext) {
-            this.selectedExecutionContextState =
-                this.getInitiallySelectedExecutionContextState();
-        }
-    }
-    addExecutionParameter(value) {
-        const _mapping = this.editorStore.graphManagerState.usableMappings[0] ?? stub_Mapping();
-        const _key = new KeyedExecutionParameter(value, PackageableElementExplicitReference.create(_mapping), stub_PackageableRuntime());
-        pureMultiExecution_addExecutionParameter(this.execution, _key, this.editorStore.changeDetectionState.observerContext);
-        this.selectedExecutionContextState = new KeyedExecutionContextState(_key, this);
-    }
-    changeKeyValue(key, value) {
-        keyedExecutionParameter_setKey(key, value);
-    }
-}
-//# sourceMappingURL=ServiceExecutionState.js.map