@finos/legend-application-studio 28.10.0 → 28.10.2

package/lib/stores/editor/sidebar-state/end-to-end-workflow/GlobalEndToEndFlowState.d.ts

@@ -13,100 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-/// <reference types="react" resolution-mode="require"/>
 import type { EditorStore } from '../../EditorStore.js';
-import { QueryConnectionEndToEndWorkflowEditorState } from '../../editor-state/end-to-end-workflow-state/EndToEndWorkflowEditorState.js';
-import { RelationalDatabaseConnectionValueState } from '../../editor-state/element-editor-state/connection/ConnectionEditorState.js';
-import { RelationalDatabaseConnection, type PureModel, PackageableConnection, PackageableRuntime, ParserError, CompilationError } from '@finos/legend-graph';
-import { type GeneratorFn, ActionState } from '@finos/legend-shared';
-import { DatabaseBuilderWizardState } from '../../editor-state/element-editor-state/connection/DatabaseBuilderWizardState.js';
-import { DatabaseModelBuilderState } from '../../editor-state/element-editor-state/connection/DatabaseModelBuilderState.js';
-import type { Entity } from '@finos/legend-storage';
-import { BaseStepperState } from '@finos/legend-art';
-export declare enum SupportedEndToEndWorkflow {
-    CREATE_QUERY_FROM_CONNECTION = "Create Query From Connection"
-}
-export declare class QueryConnectionConfirmationAndGrammarEditorStepperState extends BaseStepperState {
-    queryConnectionEndToEndWorkflowState: QueryConnectionEndToEndWorkflowState;
-    isCompilingCode: ActionState;
-    editorStore: EditorStore;
-    constructor(queryConnectionEndToEndWorkflowState: QueryConnectionEndToEndWorkflowState, stepLabel: string);
-    compile(): GeneratorFn<void>;
-    query(): GeneratorFn<void>;
-    handleNext(): GeneratorFn<void>;
-    renderStepContent(): React.ReactNode;
-}
-export declare class DatabaseModelBuilderStepperState extends BaseStepperState {
-    queryConnectionEndToEndWorkflowState: QueryConnectionEndToEndWorkflowState;
-    databaseModelBuilderState: DatabaseModelBuilderState;
-    editorStore: EditorStore;
-    constructor(queryConnectionEndToEndWorkflowState: QueryConnectionEndToEndWorkflowState, stepLabel: string, databaseModelBuilderState: DatabaseModelBuilderState);
-    updateGraphWithModels(entities: Entity[]): GeneratorFn<void>;
-    handleNext(): GeneratorFn<void>;
-    renderStepContent(): React.ReactNode;
-}
-export declare class DatabaseGrammarEditorStepperState extends BaseStepperState {
-    queryConnectionEndToEndWorkflowState: QueryConnectionEndToEndWorkflowState;
-    isCompilingGrammarCode: ActionState;
-    editorStore: EditorStore;
-    constructor(queryConnectionEndToEndWorkflowState: QueryConnectionEndToEndWorkflowState, stepLabel: string);
-    compileDatabaseGrammarCode(): GeneratorFn<void>;
-    buildDatabaseModelBuilderState(): void;
-    handleNext(): GeneratorFn<void>;
-    renderStepContent(): React.ReactNode;
-}
-export declare class DatabaseBuilderStepperState extends BaseStepperState {
-    queryConnectionEndToEndWorkflowState: QueryConnectionEndToEndWorkflowState;
-    databaseBuilderWizardState: DatabaseBuilderWizardState;
-    isGeneratingDatabaseGrammarCode: ActionState;
-    editorStore: EditorStore;
-    constructor(queryConnectionEndToEndWorkflowState: QueryConnectionEndToEndWorkflowState, stepLabel: string, databaseBuilderWizardState: DatabaseBuilderWizardState);
-    buildDatabase(): GeneratorFn<void>;
-    generateDatabaseGrammarCode(): GeneratorFn<void>;
-    handleNext(): GeneratorFn<void>;
-    renderStepContent(): React.ReactNode;
-}
-export declare class ConnectionValueStepperState extends BaseStepperState {
-    queryConnectionEndToEndWorkflowState: QueryConnectionEndToEndWorkflowState;
-    targetConnectionPath: string;
-    connectionValueState: RelationalDatabaseConnectionValueState;
-    constructor(queryConnectionEndToEndWorkflowState: QueryConnectionEndToEndWorkflowState, stepLabel: string);
-    get createConnection(): RelationalDatabaseConnection;
-    setTargetConnectionPath(val: string): void;
-    handleNext(): GeneratorFn<void>;
-    renderStepContent(): React.ReactNode;
-}
-export declare class QueryConnectionEndToEndWorkflowState {
-    activeStep: number;
-    activeStepToBaseStepperState: Map<string, BaseStepperState>;
-    activeStepToStepLabel: Map<number, string>;
-    globalEndToEndWorkflowState: GlobalEndToEndWorkflowState;
-    queryConnectionEndToEndWorkflowEditorState: QueryConnectionEndToEndWorkflowEditorState;
-    targetRuntimePath: string;
-    packageableConnection: PackageableConnection | undefined;
-    packageableRuntime: PackageableRuntime | undefined;
-    databaseGrammarCode: string;
-    runtimeGrammarCode: string;
-    connectionGrammarCode: string;
-    finalGrammarCode: string;
-    graph: PureModel;
-    isValid: boolean;
-    compileError: ParserError | CompilationError | undefined;
-    constructor(globalEndToEndWorkflowState: GlobalEndToEndWorkflowState);
-    initactiveStepToStepLabel(): void;
-    setActiveStep(step: number): void;
-    setTargetRuntimePath(val: string): void;
-    setRuntimeGrammarCode(val: string): void;
-    setDatabaseGrammarCode(code: string): void;
-    setFinalGrammarCode(val: string): void;
-    setCompileError(err: ParserError | CompilationError | undefined): void;
-    updateRuntime(newPath: string): GeneratorFn<void>;
-    reset(): void;
-}
+import { QueryConnectionEndToEndWorkflowEditorState } from '../../editor-state/end-to-end-workflow-state/QueryConnectionEndToEndWorkflowEditorState.js';
 export declare class GlobalEndToEndWorkflowState {
     editorStore: EditorStore;
-    queryConnectionEndToEndWorkflowState: QueryConnectionEndToEndWorkflowState;
-    queryConnectionEndToEndWorkflowEditorState: QueryConnectionEndToEndWorkflowEditorState;
+    queryToConnectionWorkflowEditorState: QueryConnectionEndToEndWorkflowEditorState;
     constructor(editorStore: EditorStore);
     visitWorkflow(workflow: string): void;
 }

package/lib/stores/editor/sidebar-state/end-to-end-workflow/GlobalEndToEndFlowState.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GlobalEndToEndFlowState.d.ts","sourceRoot":"","sources":["../../../../../src/stores/editor/sidebar-state/end-to-end-workflow/GlobalEndToEndFlowState.tsx"],"names":[],"mappings":"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"}
+{"version":3,"file":"GlobalEndToEndFlowState.d.ts","sourceRoot":"","sources":["../../../../../src/stores/editor/sidebar-state/end-to-end-workflow/GlobalEndToEndFlowState.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,EAAE,0CAA0C,EAAE,MAAM,4FAA4F,CAAC;AAGxJ,qBAAa,2BAA2B;IACtC,WAAW,EAAE,WAAW,CAAC;IACzB,oCAAoC,EAAE,0CAA0C,CAAC;gBAErE,WAAW,EAAE,WAAW;IAUpC,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;CAOtC"}

package/lib/stores/editor/sidebar-state/end-to-end-workflow/GlobalEndToEndFlowState.js

@@ -1,4 +1,3 @@
-import { jsx as _jsx } from "react/jsx-runtime";
 /**
  * Copyright (c) 2020-present, Goldman Sachs
  *
@@ -14,480 +13,24 @@ import { jsx as _jsx } from "react/jsx-runtime";
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { action, flow, flowResult, makeObservable, observable } from 'mobx';
-import { QueryConnectionEndToEndWorkflowEditorState } from '../../editor-state/end-to-end-workflow-state/EndToEndWorkflowEditorState.js';
-import { RelationalDatabaseConnectionValueState } from '../../editor-state/element-editor-state/connection/ConnectionEditorState.js';
-import { RelationalDatabaseConnection, LocalH2DatasourceSpecification, PackageableElementExplicitReference, stub_Database, DatabaseType, DefaultH2AuthenticationStrategy, PackageableConnection, EngineRuntime, IdentifiedConnection, generateIdentifiedConnectionId, PackageableRuntime, extractElementNameFromPath, getOrCreatePackage, extractPackagePathFromPath, getMappingCompatibleClasses, RuntimePointer, ParserError, CompilationError, observe_RelationalDatabaseConnection, } from '@finos/legend-graph';
-import { DEFAULT_H2_SQL } from '../../NewElementState.js';
-import { guaranteeNonNullable, LogEvent, assertErrorThrown, ActionState, getNonNullableEntry, } from '@finos/legend-shared';
-import { DatabaseBuilderWizardState } from '../../editor-state/element-editor-state/connection/DatabaseBuilderWizardState.js';
-import { LEGEND_STUDIO_APP_EVENT } from '../../../../__lib__/LegendStudioEvent.js';
-import { DatabaseModelBuilderState } from '../../editor-state/element-editor-state/connection/DatabaseModelBuilderState.js';
-import { EntityChangeType } from '@finos/legend-server-sdlc';
-import { packageableConnection_setConnectionValue, runtime_addIdentifiedConnection, runtime_addMapping, runtime_setMappings, } from '../../../graph-modifier/DSL_Mapping_GraphModifierHelper.js';
-import { ClassQueryBuilderState, QueryBuilderConfig, } from '@finos/legend-query-builder';
-import { BaseStepperState } from '@finos/legend-art';
-import { QUERY_CONNECTION_WORKFLOW_STEPS, QueryConnectionConfirmationAndGrammarEditor, QueryConnectionDatabaseBuilderEditor, QueryConnectionDatabaseGrammarEditor, QueryConnectionModelsEditor, QueryConnectionRelationalConnectionEditor, } from '../../../../components/editor/editor-group/end-to-end-flow-editor/QueryConnectionWorkflowEditor.js';
-export var SupportedEndToEndWorkflow;
-(function (SupportedEndToEndWorkflow) {
-    SupportedEndToEndWorkflow["CREATE_QUERY_FROM_CONNECTION"] = "Create Query From Connection";
-})(SupportedEndToEndWorkflow || (SupportedEndToEndWorkflow = {}));
-const DEFAULT_CONNECTION_PATH = 'store::MyConnection';
-const DEFAULT_RUNTIME_PATH = 'store::MyRuntime';
-const JOIN_CODE_SYNTAX = '// Please refer to pure code syntax below for how to create join' +
-    '\n' +
-    '// Join join_name(Table1.column1 = Table2.column2);' +
-    '\n';
-// step5 - confirm/update final grammar and query
-export class QueryConnectionConfirmationAndGrammarEditorStepperState extends BaseStepperState {
-    queryConnectionEndToEndWorkflowState;
-    isCompilingCode = ActionState.create();
-    editorStore;
-    constructor(queryConnectionEndToEndWorkflowState, stepLabel) {
-        super(stepLabel);
-        makeObservable(this, {
-            queryConnectionEndToEndWorkflowState: false,
-            stepLabel: observable,
-            isCompilingCode: observable,
-            handleNext: flow,
-            query: flow,
-            compile: flow,
-        });
-        this.queryConnectionEndToEndWorkflowState =
-            queryConnectionEndToEndWorkflowState;
-        this.editorStore =
-            this.queryConnectionEndToEndWorkflowState.globalEndToEndWorkflowState.editorStore;
-    }
-    *compile() {
-        try {
-            this.isCompilingCode.inProgress();
-            const compilationResult = (yield flowResult(yield this.editorStore.graphManagerState.graphManager.compileText(this.queryConnectionEndToEndWorkflowState.finalGrammarCode, this.queryConnectionEndToEndWorkflowState.graph)));
-            this.editorStore.applicationStore.notificationService.notifySuccess('Compiled successfully');
-            const entities = compilationResult.entities;
-            const newGraph = this.editorStore.graphManagerState.createNewGraph();
-            yield flowResult(this.editorStore.graphManagerState.graphManager.buildGraph(newGraph, entities, ActionState.create()));
-            this.queryConnectionEndToEndWorkflowState.graph = newGraph;
-            this.queryConnectionEndToEndWorkflowState.setCompileError(undefined);
-        }
-        catch (error) {
-            if (error instanceof ParserError || error instanceof CompilationError) {
-                this.queryConnectionEndToEndWorkflowState.setCompileError(error);
-            }
-            assertErrorThrown(error);
-            this.editorStore.applicationStore.logService.error(LogEvent.create(LEGEND_STUDIO_APP_EVENT.DATABASE_MODEL_BUILDER_FAILURE), error);
-            this.editorStore.applicationStore.notificationService.notifyError(error);
-            this.isCompilingCode.fail();
-        }
-        finally {
-            this.isCompilingCode.complete();
-        }
-    }
-    *query() {
-        const entities = (yield this.editorStore.graphManagerState.graphManager.pureCodeToEntities(this.queryConnectionEndToEndWorkflowState.finalGrammarCode));
-        const newEntities = [];
-        for (const entity of entities) {
-            newEntities.push({
-                type: EntityChangeType.CREATE,
-                entityPath: entity.path,
-                content: entity.content,
-            });
-        }
-        yield flowResult(this.editorStore.graphState.loadEntityChangesToGraph(newEntities, undefined));
-        this.editorStore.tabManagerState.openTab(this.queryConnectionEndToEndWorkflowState
-            .queryConnectionEndToEndWorkflowEditorState);
-        this.editorStore.tabManagerState.closeTab(this.queryConnectionEndToEndWorkflowState
-            .queryConnectionEndToEndWorkflowEditorState);
-        const theClass = getMappingCompatibleClasses(getNonNullableEntry(this.queryConnectionEndToEndWorkflowState.graph.mappings, 0), this.queryConnectionEndToEndWorkflowState.graph.classes)[0];
-        if (theClass) {
-            const config = new QueryBuilderConfig();
-            const queryBuilderState = new ClassQueryBuilderState(this.editorStore.applicationStore, this.editorStore.graphManagerState, config);
-            queryBuilderState.class = theClass;
-            queryBuilderState.executionContextState.mapping = getNonNullableEntry(this.queryConnectionEndToEndWorkflowState.graph.mappings, 0);
-            queryBuilderState.executionContextState.runtimeValue = new RuntimePointer(PackageableElementExplicitReference.create(getNonNullableEntry(this.queryConnectionEndToEndWorkflowState.graph.runtimes, 0)));
-            yield flowResult(this.editorStore.embeddedQueryBuilderState.setEmbeddedQueryBuilderConfiguration({
-                setupQueryBuilderState: () => queryBuilderState,
-                actionConfigs: [],
-            }));
-        }
-    }
-    *handleNext() {
-        yield flowResult(this.query()).then(() => {
-            this.queryConnectionEndToEndWorkflowState.reset();
-        });
-    }
-    renderStepContent() {
-        return (_jsx(QueryConnectionConfirmationAndGrammarEditor, { queryConnectionEndToEndWorkflowState: this.queryConnectionEndToEndWorkflowState, queryConnectionConfirmationAndGrammarEditorStepperState: this }));
-    }
-}
-// step 4 - build class/mapping/runtime from database
-export class DatabaseModelBuilderStepperState extends BaseStepperState {
-    queryConnectionEndToEndWorkflowState;
-    databaseModelBuilderState;
-    editorStore;
-    constructor(queryConnectionEndToEndWorkflowState, stepLabel, databaseModelBuilderState) {
-        super(stepLabel);
-        makeObservable(this, {
-            queryConnectionEndToEndWorkflowState: false,
-            stepLabel: observable,
-            updateGraphWithModels: flow,
-            handleNext: flow,
-        });
-        this.queryConnectionEndToEndWorkflowState =
-            queryConnectionEndToEndWorkflowState;
-        this.databaseModelBuilderState = databaseModelBuilderState;
-        this.editorStore =
-            this.queryConnectionEndToEndWorkflowState.globalEndToEndWorkflowState.editorStore;
-    }
-    *updateGraphWithModels(entities) {
-        try {
-            const newGraph = this.editorStore.graphManagerState.createNewGraph();
-            newGraph.addElement(guaranteeNonNullable(this.queryConnectionEndToEndWorkflowState.packageableConnection), this.queryConnectionEndToEndWorkflowState.packageableConnection?.package
-                ?.path);
-            const databaseBuilderStepperState = this.queryConnectionEndToEndWorkflowState.activeStepToBaseStepperState.get(QUERY_CONNECTION_WORKFLOW_STEPS.CREATE_DATABASE);
-            newGraph.addElement(databaseBuilderStepperState.databaseBuilderWizardState
-                .schemaExplorerState.database, databaseBuilderStepperState.databaseBuilderWizardState
-                .schemaExplorerState.database.package?.path);
-            yield flowResult(this.editorStore.graphManagerState.graphManager.buildGraph(newGraph, entities, ActionState.create()));
-            // create a runtime
-            if (this.queryConnectionEndToEndWorkflowState.packageableRuntime) {
-                runtime_setMappings(this.queryConnectionEndToEndWorkflowState.packageableRuntime
-                    .runtimeValue, [
-                    PackageableElementExplicitReference.create(getNonNullableEntry(newGraph.mappings, 0)),
-                ]);
-            }
-            else {
-                const runtime = new PackageableRuntime(extractElementNameFromPath(this.queryConnectionEndToEndWorkflowState.targetRuntimePath));
-                runtime.runtimeValue = new EngineRuntime();
-                runtime_addMapping(runtime.runtimeValue, PackageableElementExplicitReference.create(getNonNullableEntry(newGraph.mappings, 0)));
-                runtime_addIdentifiedConnection(runtime.runtimeValue, new IdentifiedConnection(generateIdentifiedConnectionId(runtime.runtimeValue), guaranteeNonNullable(this.queryConnectionEndToEndWorkflowState.packageableConnection).connectionValue), this.queryConnectionEndToEndWorkflowState.globalEndToEndWorkflowState
-                    .editorStore.changeDetectionState.observerContext);
-                this.queryConnectionEndToEndWorkflowState.packageableRuntime = runtime;
-            }
-            newGraph.addElement(this.queryConnectionEndToEndWorkflowState.packageableRuntime, extractPackagePathFromPath(this.queryConnectionEndToEndWorkflowState.targetRuntimePath));
-            this.queryConnectionEndToEndWorkflowState.graph = newGraph;
-            this.queryConnectionEndToEndWorkflowState.setRuntimeGrammarCode((yield this.editorStore.graphManagerState.graphManager.entitiesToPureCode([
-                this.editorStore.graphManagerState.graphManager.elementToEntity(this.queryConnectionEndToEndWorkflowState.packageableRuntime),
-            ], { pretty: true })));
-            const connectionGrammarCode = (yield this.editorStore.graphManagerState.graphManager.entitiesToPureCode([
-                this.editorStore.graphManagerState.graphManager.elementToEntity(guaranteeNonNullable(this.queryConnectionEndToEndWorkflowState.packageableConnection)),
-            ], { pretty: true }));
-            this.queryConnectionEndToEndWorkflowState.connectionGrammarCode =
-                connectionGrammarCode;
-        }
-        catch (error) {
-            assertErrorThrown(error);
-            this.editorStore.applicationStore.logService.error(LogEvent.create(LEGEND_STUDIO_APP_EVENT.DATABASE_MODEL_BUILDER_FAILURE), error);
-            this.editorStore.applicationStore.notificationService.notifyError(error);
-        }
-    }
-    *handleNext() {
-        this.queryConnectionEndToEndWorkflowState.setFinalGrammarCode(this.databaseModelBuilderState.generatedGrammarCode
-            .concat(this.queryConnectionEndToEndWorkflowState.runtimeGrammarCode)
-            .concat(this.queryConnectionEndToEndWorkflowState.databaseGrammarCode)
-            .concat(this.queryConnectionEndToEndWorkflowState.connectionGrammarCode));
-        this.queryConnectionEndToEndWorkflowState.activeStepToBaseStepperState.set(QUERY_CONNECTION_WORKFLOW_STEPS.CONFIRMATION, new QueryConnectionConfirmationAndGrammarEditorStepperState(this.queryConnectionEndToEndWorkflowState, QUERY_CONNECTION_WORKFLOW_STEPS.CONFIRMATION));
-    }
-    renderStepContent() {
-        return (_jsx(QueryConnectionModelsEditor, { databaseModelBuilderStepperState: this, queryConnectionEndToEndWorkflowState: this.queryConnectionEndToEndWorkflowState }));
-    }
-}
-// step 3 - database grammar editor
-export class DatabaseGrammarEditorStepperState extends BaseStepperState {
-    queryConnectionEndToEndWorkflowState;
-    isCompilingGrammarCode = ActionState.create();
-    editorStore;
-    constructor(queryConnectionEndToEndWorkflowState, stepLabel) {
-        super(stepLabel);
-        makeObservable(this, {
-            queryConnectionEndToEndWorkflowState: false,
-            stepLabel: observable,
-            isCompilingGrammarCode: observable,
-            buildDatabaseModelBuilderState: action,
-            compileDatabaseGrammarCode: flow,
-            handleNext: flow,
-        });
-        this.queryConnectionEndToEndWorkflowState =
-            queryConnectionEndToEndWorkflowState;
-        this.editorStore =
-            this.queryConnectionEndToEndWorkflowState.globalEndToEndWorkflowState.editorStore;
-    }
-    *compileDatabaseGrammarCode() {
-        try {
-            this.isCompilingGrammarCode.inProgress();
-            const databaseBuilderStepperState = this.queryConnectionEndToEndWorkflowState.activeStepToBaseStepperState.get(QUERY_CONNECTION_WORKFLOW_STEPS.CREATE_DATABASE);
-            const connectionValueStepperState = this.queryConnectionEndToEndWorkflowState.activeStepToBaseStepperState.get(QUERY_CONNECTION_WORKFLOW_STEPS.CREATE_CONNECTION);
-            const compilationResult = (yield flowResult(yield this.editorStore.graphManagerState.graphManager.compileText(this.queryConnectionEndToEndWorkflowState.databaseGrammarCode, this.queryConnectionEndToEndWorkflowState.graph)));
-            this.editorStore.applicationStore.notificationService.notifySuccess('Compiled successfully');
-            const entities = compilationResult.entities;
-            const newGraph = this.editorStore.graphManagerState.createNewGraph();
-            yield flowResult(this.editorStore.graphManagerState.graphManager.buildGraph(newGraph, entities, ActionState.create()));
-            if (newGraph.databases.length > 1) {
-                this.queryConnectionEndToEndWorkflowState.isValid = false;
-                this.editorStore.applicationStore.notificationService.notifyError('Please make sure there is only one databse');
-            }
-            else {
-                this.queryConnectionEndToEndWorkflowState.isValid = true;
-            }
-            // databaseBuilderWizardState.schemaExplorerState.database needs to be updated
-            databaseBuilderStepperState.databaseBuilderWizardState.schemaExplorerState.database =
-                getNonNullableEntry(newGraph.databases, 0);
-            this.queryConnectionEndToEndWorkflowState.graph = newGraph;
-            // start building packageableConnection based on database and adding it to current graph
-            const packageableConnection = new PackageableConnection(extractElementNameFromPath(connectionValueStepperState.targetConnectionPath));
-            connectionValueStepperState.connectionValueState.connection.store =
-                PackageableElementExplicitReference.create(databaseBuilderStepperState.databaseBuilderWizardState
-                    .schemaExplorerState.database);
-            packageableConnection.package = getOrCreatePackage(this.queryConnectionEndToEndWorkflowState.graph.root, connectionValueStepperState.targetConnectionPath, true, new Map());
-            packageableConnection_setConnectionValue(packageableConnection, connectionValueStepperState.connectionValueState.connection, this.queryConnectionEndToEndWorkflowState.globalEndToEndWorkflowState
-                .editorStore.changeDetectionState.observerContext);
-            this.queryConnectionEndToEndWorkflowState.packageableConnection =
-                packageableConnection;
-            this.queryConnectionEndToEndWorkflowState.graph.addElement(packageableConnection, extractPackagePathFromPath(connectionValueStepperState.targetConnectionPath));
-            this.queryConnectionEndToEndWorkflowState.setCompileError(undefined);
-            this.isCompilingGrammarCode.pass();
-        }
-        catch (error) {
-            if (error instanceof ParserError || error instanceof CompilationError) {
-                this.queryConnectionEndToEndWorkflowState.setCompileError(error);
-            }
-            this.queryConnectionEndToEndWorkflowState.isValid = false;
-            assertErrorThrown(error);
-            this.editorStore.applicationStore.logService.error(LogEvent.create(LEGEND_STUDIO_APP_EVENT.DATABASE_MODEL_BUILDER_FAILURE), error);
-            this.editorStore.applicationStore.notificationService.notifyError(error);
-            this.isCompilingGrammarCode.fail();
-        }
-        finally {
-            this.isCompilingGrammarCode.complete();
-        }
-    }
-    buildDatabaseModelBuilderState() {
-        const databaseBuilderStepperState = this.queryConnectionEndToEndWorkflowState.activeStepToBaseStepperState.get(QUERY_CONNECTION_WORKFLOW_STEPS.CREATE_DATABASE);
-        const databaseModelBuilderState = new DatabaseModelBuilderState(this.editorStore, databaseBuilderStepperState.databaseBuilderWizardState.schemaExplorerState.database, false, this.queryConnectionEndToEndWorkflowState.graph);
-        this.queryConnectionEndToEndWorkflowState.activeStepToBaseStepperState.set(QUERY_CONNECTION_WORKFLOW_STEPS.CREATE_CLASS_MAPPING_RUNTIME, new DatabaseModelBuilderStepperState(this.queryConnectionEndToEndWorkflowState, QUERY_CONNECTION_WORKFLOW_STEPS.CREATE_CLASS_MAPPING_RUNTIME, databaseModelBuilderState));
-    }
-    *handleNext() {
-        yield flowResult(this.compileDatabaseGrammarCode()).then(() => {
-            this.buildDatabaseModelBuilderState();
-        });
-    }
-    renderStepContent() {
-        return (_jsx(QueryConnectionDatabaseGrammarEditor, { queryConnectionEndToEndWorkflowState: this.queryConnectionEndToEndWorkflowState, databaseGrammarEditorStepperState: this }));
-    }
-}
-// step 2 - build database
-export class DatabaseBuilderStepperState extends BaseStepperState {
-    queryConnectionEndToEndWorkflowState;
-    databaseBuilderWizardState;
-    isGeneratingDatabaseGrammarCode = ActionState.create();
-    editorStore;
-    constructor(queryConnectionEndToEndWorkflowState, stepLabel, databaseBuilderWizardState) {
-        super(stepLabel);
-        makeObservable(this, {
-            queryConnectionEndToEndWorkflowState: false,
-            stepLabel: observable,
-            databaseBuilderWizardState: observable,
-            isGeneratingDatabaseGrammarCode: observable,
-            handleNext: flow,
-            generateDatabaseGrammarCode: flow,
-            buildDatabase: flow,
-        });
-        this.queryConnectionEndToEndWorkflowState =
-            queryConnectionEndToEndWorkflowState;
-        this.databaseBuilderWizardState = databaseBuilderWizardState;
-        this.editorStore =
-            this.queryConnectionEndToEndWorkflowState.globalEndToEndWorkflowState.editorStore;
-    }
-    *buildDatabase() {
-        try {
-            if (!this.databaseBuilderWizardState.schemaExplorerState.treeData) {
-                return;
-            }
-            yield flowResult(this.databaseBuilderWizardState.schemaExplorerState.updateDatabase());
-        }
-        catch (error) {
-            assertErrorThrown(error);
-            this.editorStore.applicationStore.logService.error(LogEvent.create(LEGEND_STUDIO_APP_EVENT.DATABASE_BUILDER_FAILURE), error);
-            this.editorStore.applicationStore.notificationService.notifyError(error);
-            this.isGeneratingDatabaseGrammarCode.fail();
-        }
-    }
-    *generateDatabaseGrammarCode() {
-        try {
-            this.isGeneratingDatabaseGrammarCode.inProgress();
-            // can't use this.databaseBuilderState.databaseGrammarCode as databaseGrammarCode might not be up to date
-            this.queryConnectionEndToEndWorkflowState.setDatabaseGrammarCode(JOIN_CODE_SYNTAX +
-                (yield this.editorStore.graphManagerState.graphManager.entitiesToPureCode([
-                    this.editorStore.graphManagerState.graphManager.elementToEntity(this.databaseBuilderWizardState.schemaExplorerState.database),
-                ], { pretty: true })));
-            this.isGeneratingDatabaseGrammarCode.pass();
-        }
-        catch (error) {
-            assertErrorThrown(error);
-            this.editorStore.applicationStore.logService.error(LogEvent.create(LEGEND_STUDIO_APP_EVENT.DATABASE_MODEL_BUILDER_FAILURE), error);
-            this.editorStore.applicationStore.notificationService.notifyError(error);
-            this.isGeneratingDatabaseGrammarCode.fail();
-        }
-    }
-    *handleNext() {
-        yield flowResult(this.buildDatabase());
-        yield flowResult(this.generateDatabaseGrammarCode());
-        this.queryConnectionEndToEndWorkflowState.activeStepToBaseStepperState.set(QUERY_CONNECTION_WORKFLOW_STEPS.EDIT_DATABASE, new DatabaseGrammarEditorStepperState(this.queryConnectionEndToEndWorkflowState, QUERY_CONNECTION_WORKFLOW_STEPS.EDIT_DATABASE));
-    }
-    renderStepContent() {
-        return (_jsx(QueryConnectionDatabaseBuilderEditor, { databaseBuilderState: this.databaseBuilderWizardState }));
-    }
-}
-// step 1 - build connection
-export class ConnectionValueStepperState extends BaseStepperState {
-    queryConnectionEndToEndWorkflowState;
-    targetConnectionPath = DEFAULT_CONNECTION_PATH;
-    connectionValueState;
-    constructor(queryConnectionEndToEndWorkflowState, stepLabel) {
-        super(stepLabel);
-        makeObservable(this, {
-            queryConnectionEndToEndWorkflowState: false,
-            stepLabel: observable,
-            targetConnectionPath: observable,
-            connectionValueState: observable,
-            setTargetConnectionPath: action,
-            handleNext: flow,
-        });
-        this.queryConnectionEndToEndWorkflowState =
-            queryConnectionEndToEndWorkflowState;
-        this.connectionValueState = new RelationalDatabaseConnectionValueState(this.queryConnectionEndToEndWorkflowState.globalEndToEndWorkflowState.editorStore, observe_RelationalDatabaseConnection(this.createConnection, this.queryConnectionEndToEndWorkflowState.globalEndToEndWorkflowState
-            .editorStore.changeDetectionState.observerContext));
-    }
-    get createConnection() {
-        const spec = new LocalH2DatasourceSpecification();
-        spec.testDataSetupSqls = [DEFAULT_H2_SQL];
-        const connection = new RelationalDatabaseConnection(PackageableElementExplicitReference.create(stub_Database()), DatabaseType.H2, spec, new DefaultH2AuthenticationStrategy());
-        return connection;
-    }
-    setTargetConnectionPath(val) {
-        this.targetConnectionPath = val;
-    }
-    *handleNext() {
-        const databaseBuilderWizardState = new DatabaseBuilderWizardState(this.queryConnectionEndToEndWorkflowState.globalEndToEndWorkflowState.editorStore, this.connectionValueState.connection, false);
-        databaseBuilderWizardState.schemaExplorerState.setMakeTargetDatabasePathEditable(true);
-        this.queryConnectionEndToEndWorkflowState.activeStepToBaseStepperState.set(QUERY_CONNECTION_WORKFLOW_STEPS.CREATE_DATABASE, new DatabaseBuilderStepperState(this.queryConnectionEndToEndWorkflowState, QUERY_CONNECTION_WORKFLOW_STEPS.CREATE_DATABASE, databaseBuilderWizardState));
-    }
-    renderStepContent() {
-        return (_jsx(QueryConnectionRelationalConnectionEditor, { queryConnectionEndToEndWorkflowState: this.queryConnectionEndToEndWorkflowState, connectionValueStepperState: this }));
-    }
-}
-export class QueryConnectionEndToEndWorkflowState {
-    activeStep;
-    activeStepToBaseStepperState = new Map();
-    activeStepToStepLabel = new Map();
-    globalEndToEndWorkflowState;
-    queryConnectionEndToEndWorkflowEditorState;
-    targetRuntimePath = DEFAULT_RUNTIME_PATH;
-    packageableConnection;
-    packageableRuntime;
-    databaseGrammarCode = '';
-    runtimeGrammarCode = '';
-    connectionGrammarCode = '';
-    finalGrammarCode = '';
-    graph;
-    isValid;
-    compileError;
-    constructor(globalEndToEndWorkflowState) {
-        makeObservable(this, {
-            globalEndToEndWorkflowState: false,
-            activeStep: observable,
-            activeStepToBaseStepperState: observable,
-            compileError: observable,
-            packageableRuntime: observable,
-            runtimeGrammarCode: observable,
-            connectionGrammarCode: observable,
-            finalGrammarCode: observable,
-            targetRuntimePath: observable,
-            isValid: observable,
-            queryConnectionEndToEndWorkflowEditorState: observable,
-            packageableConnection: observable,
-            setActiveStep: action,
-            setDatabaseGrammarCode: action,
-            setRuntimeGrammarCode: action,
-            setTargetRuntimePath: action,
-            setFinalGrammarCode: action,
-            setCompileError: action,
-            reset: action,
-            updateRuntime: flow,
-        });
-        this.activeStep = 0;
-        this.isValid = true;
-        this.globalEndToEndWorkflowState = globalEndToEndWorkflowState;
-        this.activeStepToBaseStepperState.set(QUERY_CONNECTION_WORKFLOW_STEPS.CREATE_CONNECTION, new ConnectionValueStepperState(this, QUERY_CONNECTION_WORKFLOW_STEPS.CREATE_CONNECTION));
-        this.queryConnectionEndToEndWorkflowEditorState =
-            new QueryConnectionEndToEndWorkflowEditorState(this.globalEndToEndWorkflowState.editorStore);
-        this.graph =
-            this.globalEndToEndWorkflowState.editorStore.graphManagerState.createNewGraph();
-        this.initactiveStepToStepLabel();
-    }
-    initactiveStepToStepLabel() {
-        Object.values(QUERY_CONNECTION_WORKFLOW_STEPS).forEach((val, index) => this.activeStepToStepLabel.set(index, val));
-    }
-    setActiveStep(step) {
-        this.activeStep = step;
-    }
-    setTargetRuntimePath(val) {
-        this.targetRuntimePath = val;
-    }
-    setRuntimeGrammarCode(val) {
-        this.runtimeGrammarCode = val;
-    }
-    setDatabaseGrammarCode(code) {
-        this.databaseGrammarCode = code;
-    }
-    setFinalGrammarCode(val) {
-        this.finalGrammarCode = val;
-    }
-    setCompileError(err) {
-        this.compileError = err;
-    }
-    *updateRuntime(newPath) {
-        if (this.packageableRuntime) {
-            this.packageableRuntime.package = getOrCreatePackage(this.graph.root, extractPackagePathFromPath(newPath) ?? newPath, true, new Map());
-            if (newPath.includes('::')) {
-                this.packageableRuntime.name = extractElementNameFromPath(newPath);
-            }
-            else {
-                this.packageableRuntime.name = newPath;
-            }
-            this.packageableRuntime.name = extractElementNameFromPath(newPath);
-            this.setRuntimeGrammarCode((yield this.globalEndToEndWorkflowState.editorStore.graphManagerState.graphManager.entitiesToPureCode([
-                this.globalEndToEndWorkflowState.editorStore.graphManagerState.graphManager.elementToEntity(this.packageableRuntime),
-            ], { pretty: true })));
-        }
-    }
-    reset() {
-        this.activeStep = -1;
-        this.graph =
-            this.globalEndToEndWorkflowState.editorStore.graphManagerState.createNewGraph();
-        this.packageableConnection = undefined;
-        this.packageableRuntime = undefined;
-        this.activeStepToBaseStepperState.set(QUERY_CONNECTION_WORKFLOW_STEPS.CREATE_CONNECTION, new ConnectionValueStepperState(this, QUERY_CONNECTION_WORKFLOW_STEPS.CREATE_CONNECTION));
-    }
-}
+import { makeObservable, observable } from 'mobx';
+import { QueryConnectionEndToEndWorkflowEditorState } from '../../editor-state/end-to-end-workflow-state/QueryConnectionEndToEndWorkflowEditorState.js';
+import { END_TO_END_WORKFLOWS } from '../../editor-state/end-to-end-workflow-state/EndToEndWorkflowEditorState.js';
 export class GlobalEndToEndWorkflowState {
     editorStore;
-    queryConnectionEndToEndWorkflowState;
-    queryConnectionEndToEndWorkflowEditorState;
+    queryToConnectionWorkflowEditorState;
     constructor(editorStore) {
         makeObservable(this, {
             editorStore: false,
-            queryConnectionEndToEndWorkflowState: observable,
-            queryConnectionEndToEndWorkflowEditorState: observable,
+            queryToConnectionWorkflowEditorState: observable,
         });
         this.editorStore = editorStore;
-        this.queryConnectionEndToEndWorkflowState =
-            new QueryConnectionEndToEndWorkflowState(this);
-        this.queryConnectionEndToEndWorkflowEditorState =
+        this.queryToConnectionWorkflowEditorState =
             new QueryConnectionEndToEndWorkflowEditorState(this.editorStore);
     }
     visitWorkflow(workflow) {
-        if (workflow === SupportedEndToEndWorkflow.CREATE_QUERY_FROM_CONNECTION) {
-            this.editorStore.tabManagerState.openTab(this.queryConnectionEndToEndWorkflowEditorState);
+        if (workflow === END_TO_END_WORKFLOWS.CREATE_QUERY_FROM_CONNECTION) {
+            this.editorStore.tabManagerState.openTab(this.queryToConnectionWorkflowEditorState);
         }
     }
 }