@finos/legend-application-studio 13.0.0

package/lib/stores/editor-state/element-editor-state/mapping/MappingElementState.js

@@ -0,0 +1,73 @@
+/**
+ * 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, computed, makeObservable, action, flow } from 'mobx';
+import { uuid } from '@finos/legend-shared';
+import { LambdaEditorState } from '@finos/legend-application';
+export class MappingElementState {
+    uuid = uuid();
+    editorStore;
+    mappingElement;
+    constructor(editorStore, mappingElement) {
+        makeObservable(this, {
+            mappingElement: observable,
+        });
+        this.editorStore = editorStore;
+        this.mappingElement = mappingElement;
+    }
+}
+export class SetImplementationState extends MappingElementState {
+    constructor(editorStore, setImplementation) {
+        super(editorStore, setImplementation);
+        makeObservable(this, {
+            setImplementation: computed,
+        });
+        this.mappingElement = setImplementation;
+    }
+    get setImplementation() {
+        return this.mappingElement;
+    }
+}
+export class InstanceSetImplementationState extends SetImplementationState {
+    propertyMappingStates = [];
+    selectedType;
+    constructor(editorStore, setImplementation) {
+        super(editorStore, setImplementation);
+        makeObservable(this, {
+            propertyMappingStates: observable,
+            selectedType: observable,
+            setSelectedType: action,
+            decorate: action,
+            convertPropertyMappingTransformObjects: flow,
+        });
+        this.mappingElement = setImplementation;
+    }
+    setSelectedType(type) {
+        this.selectedType = type === this.selectedType ? undefined : type;
+    }
+}
+export class PropertyMappingState extends LambdaEditorState {
+    instanceSetImplementationState;
+    propertyMapping;
+    constructor(instanceSetImplementationState, propertyMapping, lambdaString, lambdaPrefix) {
+        super(lambdaString, lambdaPrefix);
+        makeObservable(this, {
+            propertyMapping: observable,
+        });
+        this.instanceSetImplementationState = instanceSetImplementationState;
+        this.propertyMapping = propertyMapping;
+    }
+}
+//# sourceMappingURL=MappingElementState.js.map

package/lib/stores/editor-state/element-editor-state/mapping/MappingElementState.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MappingElementState.js","sourceRoot":"","sources":["../../../../../src/stores/editor-state/element-editor-state/mapping/MappingElementState.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAC1E,OAAO,EAAoB,IAAI,EAAE,MAAM,sBAAsB,CAAC;AAS9D,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAE9D,MAAM,OAAO,mBAAmB;IACrB,IAAI,GAAG,IAAI,EAAE,CAAC;IACvB,WAAW,CAAc;IACzB,cAAc,CAAiB;IAE/B,YAAY,WAAwB,EAAE,cAA8B;QAClE,cAAc,CAAC,IAAI,EAAE;YACnB,cAAc,EAAE,UAAU;SAC3B,CAAC,CAAC;QAEH,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC;QAC/B,IAAI,CAAC,cAAc,GAAG,cAAc,CAAC;IACvC,CAAC;CACF;AAED,MAAM,OAAgB,sBAAuB,SAAQ,mBAAmB;IAGtE,YAAY,WAAwB,EAAE,iBAAoC;QACxE,KAAK,CAAC,WAAW,EAAE,iBAAiB,CAAC,CAAC;QAEtC,cAAc,CAAC,IAAI,EAAE;YACnB,iBAAiB,EAAE,QAAQ;SAC5B,CAAC,CAAC;QAEH,IAAI,CAAC,cAAc,GAAG,iBAAiB,CAAC;IAC1C,CAAC;IAED,IAAI,iBAAiB;QACnB,OAAO,IAAI,CAAC,cAAc,CAAC;IAC7B,CAAC;CACF;AAED,MAAM,OAAgB,8BAA+B,SAAQ,sBAAsB;IAEjF,qBAAqB,GAA2B,EAAE,CAAC;IACnD,YAAY,CAAoB;IAEhC,YACE,WAAwB,EACxB,iBAA4C;QAE5C,KAAK,CAAC,WAAW,EAAE,iBAAiB,CAAC,CAAC;QAEtC,cAAc,CAAC,IAAI,EAAE;YACnB,qBAAqB,EAAE,UAAU;YACjC,YAAY,EAAE,UAAU;YACxB,eAAe,EAAE,MAAM;YACvB,QAAQ,EAAE,MAAM;YAChB,sCAAsC,EAAE,IAAI;SAC7C,CAAC,CAAC;QAEH,IAAI,CAAC,cAAc,GAAG,iBAAiB,CAAC;IAC1C,CAAC;IAED,eAAe,CAAC,IAAsB;QACpC,IAAI,CAAC,YAAY,GAAG,IAAI,KAAK,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC;IACpE,CAAC;CAIF;AAED,MAAM,OAAgB,oBAAqB,SAAQ,iBAAiB;IAClE,8BAA8B,CAAiC;IAC/D,eAAe,CAAkB;IAEjC,YACE,8BAA8D,EAC9D,eAAgC,EAChC,YAAoB,EACpB,YAAoB;QAEpB,KAAK,CAAC,YAAY,EAAE,YAAY,CAAC,CAAC;QAElC,cAAc,CAAC,IAAI,EAAE;YACnB,eAAe,EAAE,UAAU;SAC5B,CAAC,CAAC;QAEH,IAAI,CAAC,8BAA8B,GAAG,8BAA8B,CAAC;QACrE,IAAI,CAAC,eAAe,GAAG,eAAe,CAAC;IACzC,CAAC;CACF"}

package/lib/stores/editor-state/element-editor-state/mapping/MappingExecutionState.d.ts

@@ -0,0 +1,101 @@
+/**
+ * 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 { type MappingEditorState } from './MappingEditorState.js';
+import type { EditorStore } from '../../../EditorStore.js';
+import { type GeneratorFn } from '@finos/legend-shared';
+import { type InputData, type Mapping, type Connection, type SetImplementation, type Table, type View, type RawLambda, type EmbeddedData, type TestAssertion, Class, ObjectInputData, EngineRuntime, FlatDataInputData, RootFlatDataRecordType, RelationalInputData } from '@finos/legend-graph';
+import { ExecutionPlanState, LambdaEditorState } from '@finos/legend-application';
+export declare class MappingExecutionQueryState extends LambdaEditorState {
+    editorStore: EditorStore;
+    isInitializingLambda: boolean;
+    query: RawLambda;
+    constructor(editorStore: EditorStore, query: RawLambda);
+    get lambdaId(): string;
+    setIsInitializingLambda(val: boolean): void;
+    updateLamba(val: RawLambda): GeneratorFn<void>;
+    convertLambdaObjectToGrammarString(pretty?: boolean): GeneratorFn<void>;
+    convertLambdaGrammarStringToObject(): GeneratorFn<void>;
+}
+declare abstract class MappingExecutionInputDataState {
+    readonly uuid: string;
+    editorStore: EditorStore;
+    mapping: Mapping;
+    inputData?: InputData | undefined;
+    constructor(editorStore: EditorStore, mapping: Mapping, inputData: InputData | undefined);
+    abstract get isValid(): boolean;
+    abstract get runtime(): EngineRuntime;
+    createEmbeddedData(): EmbeddedData | undefined;
+    createAssertion(executionResult: string): TestAssertion | undefined;
+    abstract buildInputDataForTest(): InputData;
+}
+export declare const createRuntimeForExecution: (mapping: Mapping, connection: Connection, editorStore: EditorStore) => EngineRuntime;
+export declare class MappingExecutionEmptyInputDataState extends MappingExecutionInputDataState {
+    get isValid(): boolean;
+    get runtime(): EngineRuntime;
+    buildInputDataForTest(): InputData;
+}
+export declare class MappingExecutionObjectInputDataState extends MappingExecutionInputDataState {
+    inputData: ObjectInputData;
+    constructor(editorStore: EditorStore, mapping: Mapping, _class: Class);
+    get isValid(): boolean;
+    get runtime(): EngineRuntime;
+    createEmbeddedData(): EmbeddedData | undefined;
+    createAssertion(executionResult: string): TestAssertion | undefined;
+    buildInputDataForTest(): InputData;
+}
+export declare class MappingExecutionFlatDataInputDataState extends MappingExecutionInputDataState {
+    inputData: FlatDataInputData;
+    constructor(editorStore: EditorStore, mapping: Mapping, rootFlatDataRecordType: RootFlatDataRecordType);
+    get isValid(): boolean;
+    get runtime(): EngineRuntime;
+    buildInputDataForTest(): InputData;
+}
+export declare class MappingExecutionRelationalInputDataState extends MappingExecutionInputDataState {
+    inputData: RelationalInputData;
+    constructor(editorStore: EditorStore, mapping: Mapping, tableOrView: Table | View);
+    get isValid(): boolean;
+    get runtime(): EngineRuntime;
+    buildInputDataForTest(): InputData;
+}
+export declare class MappingExecutionState {
+    readonly uuid: string;
+    name: string;
+    editorStore: EditorStore;
+    mappingEditorState: MappingEditorState;
+    queryState: MappingExecutionQueryState;
+    inputDataState: MappingExecutionInputDataState;
+    showServicePathModal: boolean;
+    executionResultText?: string | undefined;
+    isExecuting: boolean;
+    isGeneratingPlan: boolean;
+    executionPlanState: ExecutionPlanState;
+    planGenerationDebugText?: string | undefined;
+    constructor(editorStore: EditorStore, mappingEditorState: MappingEditorState, name: string);
+    setQueryState: (val: MappingExecutionQueryState) => void;
+    setInputDataState: (val: MappingExecutionInputDataState) => void;
+    setExecutionResultText: (val: string | undefined) => void;
+    setShowServicePathModal: (val: boolean) => void;
+    setPlanGenerationDebugText(val: string | undefined): void;
+    reset(): void;
+    setInputDataStateBasedOnSource(source: unknown | undefined, populateWithMockData: boolean): void;
+    promoteToTest(): GeneratorFn<void>;
+    promoteToService(packagePath: string, serviceName: string): GeneratorFn<void>;
+    executeMapping(): GeneratorFn<void>;
+    generatePlan(debug: boolean): GeneratorFn<void>;
+    buildQueryWithClassMapping(setImplementation: SetImplementation | undefined): GeneratorFn<void>;
+}
+export {};
+//# sourceMappingURL=MappingExecutionState.d.ts.map

package/lib/stores/editor-state/element-editor-state/mapping/MappingExecutionState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MappingExecutionState.d.ts","sourceRoot":"","sources":["../../../../../src/stores/editor-state/element-editor-state/mapping/MappingExecutionState.ts"],"names":[],"mappings":"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"}

package/lib/stores/editor-state/element-editor-state/mapping/MappingExecutionState.js

@@ -0,0 +1,448 @@
+/**
+ * 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 { getMappingElementSource, getMappingElementTarget, generateMappingTestName, } from './MappingEditorState.js';
+import { observable, action, flow, computed, makeObservable, makeAutoObservable, flowResult, } from 'mobx';
+import { assertErrorThrown, LogEvent, guaranteeNonNullable, assertTrue, IllegalStateError, UnsupportedOperationError, uuid, tryToMinifyJSONString, toGrammarString, isValidJSONString, createUrlStringFromData, losslessStringify, guaranteeType, ContentType, generateEnumerableNameFromToken, tryToFormatLosslessJSONString, } from '@finos/legend-shared';
+import { createMockDataForMappingElementSource } from '../../../shared/MockDataUtil.js';
+import { DEFAULT_TEST_ASSERTION_PREFIX, DEFAULT_TEST_PREFIX, EqualToJson, ServiceTest, extractExecutionResultValues, LAMBDA_PIPE, GRAPH_MANAGER_EVENT, MappingTest, Class, ObjectInputData, ObjectInputType, ExpectedOutputMappingTestAssert, IdentifiedConnection, EngineRuntime, JsonModelConnection, FlatDataConnection, FlatDataInputData, Service, PureSingleExecution, RootFlatDataRecordType, PackageableElementExplicitReference, DatabaseType, RelationalDatabaseConnection, LocalH2DatasourceSpecification, DefaultH2AuthenticationStrategy, RelationalInputData, RelationalInputType, OperationSetImplementation, buildSourceInformationSourceId, TableAlias, stub_RawLambda, isStubbed_RawLambda, generateIdentifiedConnectionId, ServiceTestSuite, TestData, ConnectionTestData, DEFAULT_TEST_SUITE_PREFIX, } from '@finos/legend-graph';
+import { ActionAlertActionType, ActionAlertType, ExecutionPlanState, LambdaEditorState, TAB_SIZE, } from '@finos/legend-application';
+import { objectInputData_setData, runtime_addIdentifiedConnection, runtime_addMapping, } from '../../../graphModifier/DSLMapping_GraphModifierHelper.js';
+import { flatData_setData } from '../../../graphModifier/StoreFlatData_GraphModifierHelper.js';
+import { service_addTestSuite, service_initNewService, service_setExecution, } from '../../../graphModifier/DSLService_GraphModifierHelper.js';
+import { localH2DatasourceSpecification_setTestDataSetupCsv, localH2DatasourceSpecification_setTestDataSetupSqls, relationalInputData_setData, } from '../../../graphModifier/StoreRelational_GraphModifierHelper.js';
+import { createEmptyEqualToJsonAssertion, createBareExternalFormat, } from '../../../shared/testable/TestableUtils.js';
+import { SERIALIZATION_FORMAT } from '../service/testable/ServiceTestEditorState.js';
+export class MappingExecutionQueryState extends LambdaEditorState {
+    editorStore;
+    isInitializingLambda = false;
+    query;
+    constructor(editorStore, query) {
+        super('', LAMBDA_PIPE);
+        makeObservable(this, {
+            query: observable,
+            isInitializingLambda: observable,
+            setIsInitializingLambda: action,
+            updateLamba: flow,
+        });
+        this.editorStore = editorStore;
+        this.query = query;
+    }
+    get lambdaId() {
+        return buildSourceInformationSourceId([this.uuid]);
+    }
+    setIsInitializingLambda(val) {
+        this.isInitializingLambda = val;
+    }
+    *updateLamba(val) {
+        this.query = val;
+        yield flowResult(this.convertLambdaObjectToGrammarString(true));
+    }
+    *convertLambdaObjectToGrammarString(pretty) {
+        if (!isStubbed_RawLambda(this.query)) {
+            try {
+                const lambdas = new Map();
+                lambdas.set(this.lambdaId, this.query);
+                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.log.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();
+    }
+}
+class MappingExecutionInputDataState {
+    uuid = uuid();
+    editorStore;
+    mapping;
+    inputData;
+    constructor(editorStore, mapping, inputData) {
+        this.editorStore = editorStore;
+        this.mapping = mapping;
+        this.inputData = inputData;
+    }
+    createEmbeddedData() {
+        return undefined;
+    }
+    createAssertion(executionResult) {
+        return undefined;
+    }
+}
+export const createRuntimeForExecution = (mapping, connection, editorStore) => {
+    const runtime = new EngineRuntime();
+    runtime_addMapping(runtime, PackageableElementExplicitReference.create(mapping));
+    runtime_addIdentifiedConnection(runtime, new IdentifiedConnection(generateIdentifiedConnectionId(runtime), connection), editorStore.changeDetectionState.observerContext);
+    return runtime;
+};
+export class MappingExecutionEmptyInputDataState extends MappingExecutionInputDataState {
+    get isValid() {
+        return false;
+    }
+    get runtime() {
+        throw new IllegalStateError('Mapping execution runtime information is not specified');
+    }
+    buildInputDataForTest() {
+        throw new IllegalStateError('Mapping execution runtime information is not specified');
+    }
+}
+// TODO?: handle XML
+export class MappingExecutionObjectInputDataState extends MappingExecutionInputDataState {
+    constructor(editorStore, mapping, _class) {
+        super(editorStore, mapping, new ObjectInputData(PackageableElementExplicitReference.create(guaranteeNonNullable(_class)), ObjectInputType.JSON, tryToMinifyJSONString('{}')));
+        makeObservable(this, {
+            isValid: computed,
+        });
+    }
+    get isValid() {
+        return isValidJSONString(this.inputData.data);
+    }
+    get runtime() {
+        assertTrue(this.isValid, 'Model-to-model mapping execution test data is not a valid JSON string');
+        const engineConfig = this.editorStore.graphManagerState.graphManager.TEMPORARY__getEngineConfig();
+        return createRuntimeForExecution(this.mapping, new JsonModelConnection(PackageableElementExplicitReference.create(this.editorStore.graphManagerState.graph.modelStore), PackageableElementExplicitReference.create(guaranteeNonNullable(this.inputData.sourceClass.value)), createUrlStringFromData(tryToMinifyJSONString(this.inputData.data), ContentType.APPLICATION_JSON, engineConfig.useBase64ForAdhocConnectionDataUrls)), this.editorStore);
+    }
+    createEmbeddedData() {
+        const embeddedData = createBareExternalFormat();
+        embeddedData.data = tryToFormatLosslessJSONString(tryToMinifyJSONString(this.inputData.data));
+        return embeddedData;
+    }
+    createAssertion(executionResult) {
+        const jsonAssertion = new EqualToJson();
+        jsonAssertion.id = generateEnumerableNameFromToken([], DEFAULT_TEST_ASSERTION_PREFIX);
+        const expected = createBareExternalFormat();
+        expected.data = toGrammarString(executionResult);
+        jsonAssertion.expected = expected;
+        return jsonAssertion;
+    }
+    buildInputDataForTest() {
+        return new ObjectInputData(PackageableElementExplicitReference.create(guaranteeNonNullable(this.inputData.sourceClass.value)), this.inputData.inputType, tryToMinifyJSONString(this.inputData.data));
+    }
+}
+export class MappingExecutionFlatDataInputDataState extends MappingExecutionInputDataState {
+    constructor(editorStore, mapping, rootFlatDataRecordType) {
+        super(editorStore, mapping, new FlatDataInputData(PackageableElementExplicitReference.create(guaranteeNonNullable(rootFlatDataRecordType._OWNER._OWNER)), ''));
+        makeObservable(this, {
+            isValid: computed,
+        });
+    }
+    get isValid() {
+        return true;
+    }
+    get runtime() {
+        const engineConfig = this.editorStore.graphManagerState.graphManager.TEMPORARY__getEngineConfig();
+        return createRuntimeForExecution(this.mapping, new FlatDataConnection(PackageableElementExplicitReference.create(guaranteeNonNullable(this.inputData.sourceFlatData.value)), createUrlStringFromData(this.inputData.data, ContentType.TEXT_PLAIN, engineConfig.useBase64ForAdhocConnectionDataUrls)), this.editorStore);
+    }
+    buildInputDataForTest() {
+        return new FlatDataInputData(PackageableElementExplicitReference.create(guaranteeNonNullable(this.inputData.sourceFlatData.value)), this.inputData.data);
+    }
+}
+export class MappingExecutionRelationalInputDataState extends MappingExecutionInputDataState {
+    constructor(editorStore, mapping, tableOrView) {
+        super(editorStore, mapping, new RelationalInputData(PackageableElementExplicitReference.create(guaranteeNonNullable(tableOrView.schema._OWNER)), '', RelationalInputType.SQL));
+        makeObservable(this, {
+            isValid: computed,
+        });
+    }
+    get isValid() {
+        return true;
+    }
+    get runtime() {
+        const datasourceSpecification = new LocalH2DatasourceSpecification();
+        switch (this.inputData.inputType) {
+            case RelationalInputType.SQL:
+                localH2DatasourceSpecification_setTestDataSetupSqls(datasourceSpecification, 
+                // NOTE: this is a gross simplification of handling the input for relational input data
+                [this.inputData.data]);
+                break;
+            case RelationalInputType.CSV:
+                localH2DatasourceSpecification_setTestDataSetupCsv(datasourceSpecification, this.inputData.data);
+                break;
+            default:
+                throw new UnsupportedOperationError(`Invalid input data type`);
+        }
+        return createRuntimeForExecution(this.mapping, new RelationalDatabaseConnection(PackageableElementExplicitReference.create(guaranteeNonNullable(this.inputData.database.value)), DatabaseType.H2, datasourceSpecification, new DefaultH2AuthenticationStrategy()), this.editorStore);
+    }
+    buildInputDataForTest() {
+        return new RelationalInputData(PackageableElementExplicitReference.create(guaranteeNonNullable(this.inputData.database.value)), this.inputData.data, this.inputData.inputType);
+    }
+}
+export class MappingExecutionState {
+    uuid = uuid();
+    name;
+    editorStore;
+    mappingEditorState;
+    queryState;
+    inputDataState;
+    showServicePathModal = false;
+    executionResultText; // NOTE: stored as lossless JSON text
+    isExecuting = false;
+    isGeneratingPlan = false;
+    executionPlanState;
+    planGenerationDebugText;
+    constructor(editorStore, mappingEditorState, name) {
+        makeAutoObservable(this, {
+            editorStore: false,
+            mappingEditorState: false,
+            executionPlanState: observable,
+            setQueryState: action,
+            setInputDataState: action,
+            setExecutionResultText: action,
+            setPlanGenerationDebugText: action,
+            setShowServicePathModal: action,
+            setInputDataStateBasedOnSource: action,
+            reset: action,
+        });
+        this.editorStore = editorStore;
+        this.mappingEditorState = mappingEditorState;
+        this.name = name;
+        this.queryState = new MappingExecutionQueryState(editorStore, stub_RawLambda());
+        this.inputDataState = new MappingExecutionEmptyInputDataState(editorStore, mappingEditorState.mapping, undefined);
+        this.executionPlanState = new ExecutionPlanState(this.editorStore.applicationStore, this.editorStore.graphManagerState);
+    }
+    setQueryState = (val) => {
+        this.queryState = val;
+    };
+    setInputDataState = (val) => {
+        this.inputDataState = val;
+    };
+    setExecutionResultText = (val) => {
+        this.executionResultText = val;
+    };
+    setShowServicePathModal = (val) => {
+        this.showServicePathModal = val;
+    };
+    setPlanGenerationDebugText(val) {
+        this.planGenerationDebugText = val;
+    }
+    reset() {
+        this.queryState = new MappingExecutionQueryState(this.editorStore, stub_RawLambda());
+        this.inputDataState = new MappingExecutionEmptyInputDataState(this.editorStore, this.mappingEditorState.mapping, undefined);
+        this.setExecutionResultText(undefined);
+    }
+    setInputDataStateBasedOnSource(source, populateWithMockData) {
+        if (source instanceof Class) {
+            const newRuntimeState = new MappingExecutionObjectInputDataState(this.editorStore, this.mappingEditorState.mapping, source);
+            if (populateWithMockData) {
+                objectInputData_setData(newRuntimeState.inputData, createMockDataForMappingElementSource(source, this.editorStore));
+            }
+            this.setInputDataState(newRuntimeState);
+        }
+        else if (source instanceof RootFlatDataRecordType) {
+            const newRuntimeState = new MappingExecutionFlatDataInputDataState(this.editorStore, this.mappingEditorState.mapping, source);
+            if (populateWithMockData) {
+                flatData_setData(newRuntimeState.inputData, createMockDataForMappingElementSource(source, this.editorStore));
+            }
+            this.setInputDataState(newRuntimeState);
+        }
+        else if (source instanceof TableAlias) {
+            const newRuntimeState = new MappingExecutionRelationalInputDataState(this.editorStore, this.mappingEditorState.mapping, source.relation.value);
+            if (populateWithMockData) {
+                relationalInputData_setData(newRuntimeState.inputData, createMockDataForMappingElementSource(source, this.editorStore));
+            }
+            this.setInputDataState(newRuntimeState);
+        }
+        else if (source === undefined) {
+            this.setInputDataState(new MappingExecutionEmptyInputDataState(this.editorStore, this.mappingEditorState.mapping, undefined));
+        }
+        else {
+            this.editorStore.applicationStore.notifyWarning(new UnsupportedOperationError(`Can't build input data for the specified source`, source));
+        }
+    }
+    *promoteToTest() {
+        try {
+            const query = this.queryState.query;
+            if (!isStubbed_RawLambda(this.queryState.query) &&
+                this.inputDataState.isValid &&
+                this.inputDataState.inputData &&
+                this.executionResultText) {
+                const inputData = this.inputDataState.buildInputDataForTest();
+                const assert = new ExpectedOutputMappingTestAssert(toGrammarString(this.executionResultText));
+                const mappingTest = new MappingTest(generateMappingTestName(this.mappingEditorState.mapping), query, [inputData], assert);
+                yield flowResult(this.mappingEditorState.addTest(mappingTest));
+                this.mappingEditorState.closeTab(this); // after promoting to test, remove the execution state
+            }
+        }
+        catch (error) {
+            assertErrorThrown(error);
+            this.editorStore.applicationStore.log.error(LogEvent.create(GRAPH_MANAGER_EVENT.EXECUTION_FAILURE), error);
+            this.editorStore.applicationStore.notifyError(error);
+        }
+    }
+    *promoteToService(packagePath, serviceName) {
+        try {
+            const query = this.queryState.query;
+            if (!isStubbed_RawLambda(this.queryState.query) &&
+                this.inputDataState.isValid &&
+                this.executionResultText) {
+                if (this.inputDataState instanceof MappingExecutionObjectInputDataState) {
+                    const service = new Service(serviceName);
+                    const engineRuntime = this.inputDataState.runtime;
+                    service_initNewService(service);
+                    const pureSingleExecution = new PureSingleExecution(query, service, PackageableElementExplicitReference.create(this.mappingEditorState.mapping), engineRuntime);
+                    service_setExecution(service, pureSingleExecution, this.editorStore.changeDetectionState.observerContext);
+                    const suite = new ServiceTestSuite();
+                    suite.id = generateEnumerableNameFromToken([], DEFAULT_TEST_SUITE_PREFIX);
+                    suite.testData = new TestData();
+                    const embeddedData = this.inputDataState.createEmbeddedData();
+                    const connection = engineRuntime.connections[0]?.storeConnections[0];
+                    if (embeddedData && connection) {
+                        const connectionTestData = new ConnectionTestData();
+                        connectionTestData.connectionId = connection.id;
+                        connectionTestData.testData = embeddedData;
+                        suite.testData.connectionsTestData = [connectionTestData];
+                    }
+                    const test = new ServiceTest();
+                    test.serializationFormat = SERIALIZATION_FORMAT.PURE;
+                    test.id = generateEnumerableNameFromToken([], DEFAULT_TEST_PREFIX);
+                    test.__parent = suite;
+                    suite.tests = [test];
+                    const assertion = this.inputDataState.createAssertion(this.executionResultText) ??
+                        createEmptyEqualToJsonAssertion(test);
+                    test.assertions = [assertion];
+                    assertion.parentTest = test;
+                    service_addTestSuite(service, suite, this.editorStore.changeDetectionState.observerContext);
+                    yield flowResult(this.editorStore.addElement(service, packagePath, true));
+                }
+                else {
+                    throw new UnsupportedOperationError(`Can't build service from input data state`, this.inputDataState);
+                }
+            }
+        }
+        catch (error) {
+            assertErrorThrown(error);
+            this.editorStore.applicationStore.log.error(LogEvent.create(GRAPH_MANAGER_EVENT.EXECUTION_FAILURE), error);
+            this.editorStore.applicationStore.notifyError(error);
+        }
+    }
+    *executeMapping() {
+        try {
+            const query = this.queryState.query;
+            const runtime = this.inputDataState.runtime;
+            if (!isStubbed_RawLambda(this.queryState.query) &&
+                this.inputDataState.isValid &&
+                !this.isExecuting) {
+                this.isExecuting = true;
+                const result = (yield this.editorStore.graphManagerState.graphManager.executeMapping(query, this.mappingEditorState.mapping, runtime, this.editorStore.graphManagerState.graph, {
+                    useLosslessParse: true,
+                }));
+                this.setExecutionResultText(losslessStringify(extractExecutionResultValues(result), undefined, TAB_SIZE));
+            }
+        }
+        catch (error) {
+            assertErrorThrown(error);
+            this.editorStore.applicationStore.log.error(LogEvent.create(GRAPH_MANAGER_EVENT.EXECUTION_FAILURE), error);
+            this.editorStore.applicationStore.notifyError(error);
+            this.setExecutionResultText('');
+        }
+        finally {
+            this.isExecuting = false;
+        }
+    }
+    *generatePlan(debug) {
+        try {
+            const query = this.queryState.query;
+            const runtime = this.inputDataState.runtime;
+            if (!isStubbed_RawLambda(this.queryState.query) &&
+                this.inputDataState.isValid &&
+                !this.isGeneratingPlan) {
+                this.isGeneratingPlan = true;
+                let rawPlan;
+                if (debug) {
+                    const debugResult = (yield this.editorStore.graphManagerState.graphManager.debugExecutionPlanGeneration(query, this.mappingEditorState.mapping, runtime, this.editorStore.graphManagerState.graph));
+                    rawPlan = debugResult.plan;
+                    this.executionPlanState.setDebugText(debugResult.debug);
+                }
+                else {
+                    rawPlan =
+                        (yield this.editorStore.graphManagerState.graphManager.generateExecutionPlan(query, this.mappingEditorState.mapping, runtime, this.editorStore.graphManagerState.graph));
+                }
+                try {
+                    this.executionPlanState.setRawPlan(rawPlan);
+                    const plan = this.editorStore.graphManagerState.graphManager.buildExecutionPlan(rawPlan, this.editorStore.graphManagerState.graph);
+                    this.executionPlanState.setPlan(plan);
+                }
+                catch {
+                    // do nothing
+                }
+            }
+        }
+        catch (error) {
+            assertErrorThrown(error);
+            this.editorStore.applicationStore.log.error(LogEvent.create(GRAPH_MANAGER_EVENT.EXECUTION_FAILURE), error);
+            this.editorStore.applicationStore.notifyError(error);
+        }
+        finally {
+            this.isGeneratingPlan = false;
+        }
+    }
+    *buildQueryWithClassMapping(setImplementation) {
+        // do all the necessary updates
+        this.setExecutionResultText(undefined);
+        yield flowResult(this.queryState.updateLamba(setImplementation
+            ? this.editorStore.graphManagerState.graphManager.HACKY__createGetAllLambda(guaranteeType(getMappingElementTarget(setImplementation), Class))
+            : stub_RawLambda()));
+        // Attempt to generate data for input data panel as we pick the class mapping:
+        // - If the source panel is empty right now, automatically try to generate input data:
+        //   - We generate based on the class mapping, if it's concrete
+        //   - If the class mapping is operation, output a warning message
+        // - If the source panel is non-empty (show modal), show an option to keep current input data
+        if (setImplementation) {
+            if (this.inputDataState instanceof MappingExecutionEmptyInputDataState) {
+                if (setImplementation instanceof OperationSetImplementation) {
+                    this.editorStore.applicationStore.notifyWarning(`Can't auto-generate input data for operation class mapping. Please pick a concrete class mapping instead`);
+                }
+                else {
+                    this.setInputDataStateBasedOnSource(getMappingElementSource(setImplementation, this.editorStore.pluginManager.getApplicationPlugins()), true);
+                }
+            }
+            else {
+                this.editorStore.setActionAlertInfo({
+                    message: 'Mapping execution input data is already set',
+                    prompt: 'Do you want to regenerate the input data?',
+                    type: ActionAlertType.CAUTION,
+                    onEnter: () => this.editorStore.setBlockGlobalHotkeys(true),
+                    onClose: () => this.editorStore.setBlockGlobalHotkeys(false),
+                    actions: [
+                        {
+                            label: 'Regenerate',
+                            type: ActionAlertActionType.PROCEED_WITH_CAUTION,
+                            handler: () => this.setInputDataStateBasedOnSource(getMappingElementSource(setImplementation, this.editorStore.pluginManager.getApplicationPlugins()), true),
+                        },
+                        {
+                            label: 'Keep my input data',
+                            type: ActionAlertActionType.PROCEED,
+                            default: true,
+                        },
+                    ],
+                });
+            }
+        }
+    }
+}
+//# sourceMappingURL=MappingExecutionState.js.map