@finos/legend-application-studio 25.0.6 → 26.0.0

package/src/stores/editor/EditorStore.ts

@@ -101,7 +101,6 @@ import { GraphEditFormModeState } from './GraphEditFormModeState.js';
 import type { GraphEditorMode } from './GraphEditorMode.js';
 import { GraphEditGrammarModeState } from './GraphEditGrammarModeState.js';
 import { GlobalBulkServiceRegistrationState } from './sidebar-state/BulkServiceRegistrationState.js';
-import { EditorDepotState } from './EditorDepotState.js';
 
 export abstract class EditorExtensionState {
   /**
@@ -118,6 +117,7 @@ export class EditorStore implements CommandRegistrar {
   readonly pluginManager: LegendStudioPluginManager;
 
   readonly initState = ActionState.create();
+
   initialEntityPath?: string | undefined;
   editorMode: EditorMode;
   // NOTE: once we clear up the editor store to make modes more separated
@@ -130,7 +130,6 @@ export class EditorStore implements CommandRegistrar {
   editorExtensionStates: EditorExtensionState[] = [];
   explorerTreeState: ExplorerTreeState;
   sdlcState: EditorSDLCState;
-  depotState: EditorDepotState;
   graphState: EditorGraphState;
   graphManagerState: GraphManagerState;
   graphEditorMode: GraphEditorMode;
@@ -213,7 +212,6 @@ export class EditorStore implements CommandRegistrar {
     this.editorMode = new StandardEditorMode(this);
 
     this.sdlcState = new EditorSDLCState(this);
-    this.depotState = new EditorDepotState(this);
     this.graphState = new EditorGraphState(this);
     this.graphManagerState = new GraphManagerState(
       applicationStore.pluginManager,
@@ -669,6 +667,20 @@ export class EditorStore implements CommandRegistrar {
   }
 
   private *initStandardMode(): GeneratorFn<void> {
+    const projectId = this.sdlcState.activeProject.projectId;
+    const activeWorkspace = this.sdlcState.activeWorkspace;
+    const projectConfiguration = (yield this.sdlcServerClient.getConfiguration(
+      projectId,
+      activeWorkspace,
+    )) as PlainObject<ProjectConfiguration>;
+    this.projectConfigurationEditorState.setProjectConfiguration(
+      ProjectConfiguration.serialization.fromJson(projectConfiguration),
+    );
+    // make sure we set the original project configuration to a different object
+    this.projectConfigurationEditorState.setOriginalProjectConfiguration(
+      ProjectConfiguration.serialization.fromJson(projectConfiguration),
+    );
+
     yield Promise.all([
       this.buildGraph(),
       this.sdlcState.checkIfWorkspaceIsOutdated(),
@@ -678,11 +690,14 @@ export class EditorStore implements CommandRegistrar {
       this.graphState.graphGenerationState.fetchAvailableFileGenerationDescriptions(),
       this.graphState.graphGenerationState.externalFormatState.fetchExternalFormatsDescriptions(),
       this.sdlcState.fetchProjectVersions(),
-      this.depotState.fetchProjectVersions(),
+      this.sdlcState.fetchPublishedProjectVersions(),
     ]);
   }
 
   private *initConflictResolutionMode(): GeneratorFn<void> {
+    yield flowResult(
+      this.conflictResolutionState.initProjectConfigurationInConflictResolutionMode(),
+    );
     this.applicationStore.alertService.setActionAlertInfo({
       message: 'Failed to update workspace.',
       prompt:
@@ -715,33 +730,23 @@ export class EditorStore implements CommandRegistrar {
       this.graphState.graphGenerationState.fetchAvailableFileGenerationDescriptions(),
       this.graphState.graphGenerationState.externalFormatState.fetchExternalFormatsDescriptions(),
       this.sdlcState.fetchProjectVersions(),
-      this.depotState.fetchProjectVersions(),
+      this.sdlcState.fetchPublishedProjectVersions(),
     ]);
   }
 
   *buildGraph(graphEntities?: Entity[]): GeneratorFn<void> {
     const startTime = Date.now();
     let entities: Entity[];
-    let projectConfiguration: PlainObject<ProjectConfiguration>;
 
     this.initState.setMessage(`Fetching entities...`);
     try {
       // fetch workspace entities and config at the same time
       const projectId = this.sdlcState.activeProject.projectId;
       const activeWorkspace = this.sdlcState.activeWorkspace;
-      const result = (yield Promise.all([
-        this.sdlcServerClient.getEntities(projectId, activeWorkspace),
-        this.sdlcServerClient.getConfiguration(projectId, activeWorkspace),
-      ])) as [Entity[], PlainObject<ProjectConfiguration>];
-      entities = result[0];
-      projectConfiguration = result[1];
-      this.projectConfigurationEditorState.setProjectConfiguration(
-        ProjectConfiguration.serialization.fromJson(projectConfiguration),
-      );
-      // make sure we set the original project configuration to a different object
-      this.projectConfigurationEditorState.setOriginalProjectConfiguration(
-        ProjectConfiguration.serialization.fromJson(projectConfiguration),
-      );
+      entities = (yield this.sdlcServerClient.getEntities(
+        projectId,
+        activeWorkspace,
+      )) as Entity[];
       this.changeDetectionState.workspaceLocalLatestRevisionState.setEntities(
         entities,
       );

package/src/stores/editor/EditorTabManagerState.ts

@@ -139,10 +139,7 @@ export class EditorTabManagerState extends TabManagerState {
         return elementEditorState;
       }
     }
-    throw new UnsupportedOperationError(
-      `Can't create editor state for element: no compatible editor state creator available from plugins`,
-      element,
-    );
+    return new UnsupportedElementEditorState(this.editorStore, element);
   }
 
   refreshCurrentEntityDiffViewer(): void {

package/src/stores/editor/ExplorerTreeState.ts

@@ -48,8 +48,10 @@ import {
   getElementRootPackage,
   isDependencyElement,
   type Class,
+  type RelationalDatabaseConnection,
 } from '@finos/legend-graph';
 import { APPLICATION_EVENT } from '@finos/legend-application';
+import { DatabaseBuilderState } from './editor-state/element-editor-state/connection/DatabaseBuilderState.js';
 
 export enum ExplorerTreeRootPackageLabel {
   FILE_GENERATION = 'generated-files',
@@ -73,6 +75,7 @@ export class ExplorerTreeState {
 
   elementToRename?: PackageableElement | undefined;
   classToGenerateSampleData?: Class | undefined;
+  databaseBuilderState: DatabaseBuilderState | undefined;
 
   constructor(editorStore: EditorStore) {
     makeObservable(this, {
@@ -85,6 +88,7 @@ export class ExplorerTreeState {
       selectedNode: observable.ref,
       elementToRename: observable,
       classToGenerateSampleData: observable,
+      databaseBuilderState: observable,
       setTreeData: action,
       setGenerationTreeData: action,
       setSystemTreeData: action,
@@ -99,6 +103,8 @@ export class ExplorerTreeState {
       buildTreeInTextMode: action,
       openExplorerTreeNodes: action,
       reprocess: action,
+      buildDbBuilderState: action,
+      setDatabaseBuilderState: action,
       onTreeNodeSelect: action,
       openNode: action,
     });
@@ -170,6 +176,22 @@ export class ExplorerTreeState {
     this.classToGenerateSampleData = val;
   }
 
+  setDatabaseBuilderState(val: DatabaseBuilderState | undefined): void {
+    this.databaseBuilderState = val;
+  }
+  buildDbBuilderState(
+    val: RelationalDatabaseConnection,
+    isReadOnly: boolean,
+  ): void {
+    const dbBuilderState = new DatabaseBuilderState(
+      this.editorStore,
+      val,
+      isReadOnly,
+    );
+    dbBuilderState.setShowModal(true);
+    this.setDatabaseBuilderState(dbBuilderState);
+  }
+
   setSelectedNode(node: PackageTreeNodeData | undefined): void {
     if (this.selectedNode) {
       this.selectedNode.isSelected = false;

package/src/stores/editor/GraphEditGrammarModeState.ts

@@ -26,6 +26,7 @@ import {
   GraphBuilderError,
   type GraphManagerOperationReport,
   reportGraphAnalytics,
+  type SourceInformation,
 } from '@finos/legend-graph';
 import {
   type GeneratorFn,
@@ -55,19 +56,11 @@ export class GraphEditGrammarModeState extends GraphEditorMode {
     super(editorStore);
     makeObservable(this, {
       grammarTextEditorState: observable,
-      setGraphGrammar: flow,
-      setGraphGrammarFromEntites: flow,
       compileText: flow,
     });
     this.grammarTextEditorState = new GrammarTextEditorState(this.editorStore);
   }
 
-  async computeEntitiesFromCurrentGrammar(): Promise<Entity[]> {
-    return this.editorStore.graphManagerState.graphManager.pureCodeToEntities(
-      this.grammarTextEditorState.graphGrammarText,
-    );
-  }
-
   *initialize(isFallback?: boolean): GeneratorFn<void> {
     this.editorStore.localChangesState = new TextLocalChangesState(
       this.editorStore,
@@ -76,9 +69,21 @@ export class GraphEditGrammarModeState extends GraphEditorMode {
     this.editorStore.graphState.clearProblems();
     this.editorStore.changeDetectionState.stop();
     try {
+      const sourceInformationIndex = new Map<string, SourceInformation>();
+      const entities =
+        (yield this.editorStore.graphManagerState.graphManager.pureCodeToEntities(
+          this.grammarTextEditorState.graphGrammarText,
+          {
+            sourceInformationIndex,
+          },
+        )) as Entity[];
+      this.grammarTextEditorState.setSourceInformationIndex(
+        sourceInformationIndex,
+      );
+
       yield flowResult(
         this.editorStore.changeDetectionState.computeLocalChangesInTextMode(
-          (yield this.computeEntitiesFromCurrentGrammar()) as Entity[],
+          entities,
         ),
       );
     } catch (error) {
@@ -100,32 +105,19 @@ export class GraphEditGrammarModeState extends GraphEditorMode {
     if (
       this.editorStore.tabManagerState.currentTab instanceof ElementEditorState
     ) {
-      this.grammarTextEditorState.setCurrentElementLabelRegexString(
-        this.editorStore.tabManagerState.currentTab.element,
-      );
+      const sourceInformation =
+        this.grammarTextEditorState.sourceInformationIndex.get(
+          this.editorStore.tabManagerState.currentTab.element.path,
+        );
+      if (sourceInformation) {
+        this.grammarTextEditorState.setForcedCursorPosition({
+          lineNumber: sourceInformation.startLine,
+          column: 0,
+        });
+      }
     }
   }
 
-  *setGraphGrammarFromEntites(entities: Entity[]): GeneratorFn<void> {
-    const editorGrammar =
-      (yield this.editorStore.graphManagerState.graphManager.entitiesToPureCode(
-        entities,
-      )) as string;
-    yield flowResult(
-      this.grammarTextEditorState.setGraphGrammarText(editorGrammar),
-    );
-  }
-
-  *setGraphGrammar(): GeneratorFn<void> {
-    const graphGrammar =
-      (yield this.editorStore.graphManagerState.graphManager.graphToPureCode(
-        this.editorStore.graphManagerState.graph,
-      )) as string;
-    yield flowResult(
-      this.grammarTextEditorState.setGraphGrammarText(graphGrammar),
-    );
-  }
-
   *compileText(
     options?: {
       onError?: () => void;
@@ -324,6 +316,9 @@ export class GraphEditGrammarModeState extends GraphEditorMode {
           }
         }
       }
+      this.grammarTextEditorState.setSourceInformationIndex(
+        compilationResult.sourceInformationIndex,
+      );
 
       yield flowResult(this.updateGraphAndApplication(entities));
 
@@ -492,21 +487,36 @@ export class GraphEditGrammarModeState extends GraphEditorMode {
     isGraphBuildFailure?: boolean;
   }): GeneratorFn<void> {
     if (fallbackOptions?.isGraphBuildFailure) {
-      yield flowResult(
-        this.setGraphGrammarFromEntites(
+      const editorGrammar =
+        (yield this.editorStore.graphManagerState.graphManager.entitiesToPureCode(
           this.editorStore.changeDetectionState
             .workspaceLocalLatestRevisionState.entities,
-        ),
+          { pretty: true },
+        )) as string;
+      yield flowResult(
+        this.grammarTextEditorState.setGraphGrammarText(editorGrammar),
       );
     } else {
-      yield flowResult(this.setGraphGrammar());
+      const graphGrammar =
+        (yield this.editorStore.graphManagerState.graphManager.graphToPureCode(
+          this.editorStore.graphManagerState.graph,
+          { pretty: true },
+        )) as string;
+      yield flowResult(
+        this.grammarTextEditorState.setGraphGrammarText(graphGrammar),
+      );
     }
     this.editorStore.applicationStore.alertService.setBlockingAlert(undefined);
   }
 
   openElement(element: PackageableElement): void {
-    // in text mode, we want to select the block of code that corresponds to the element if possible
-    // the cheap way to do this is to search by element label text, e.g. `Mapping some::package::someMapping`
-    this.grammarTextEditorState.setCurrentElementLabelRegexString(element);
+    const sourceInformation =
+      this.grammarTextEditorState.sourceInformationIndex.get(element.path);
+    if (sourceInformation) {
+      this.grammarTextEditorState.setForcedCursorPosition({
+        lineNumber: sourceInformation.startLine,
+        column: 0,
+      });
+    }
   }
 }

package/src/stores/editor/editor-state/GrammarTextEditorState.ts

@@ -16,75 +16,28 @@
 
 import type { EditorStore } from '../EditorStore.js';
 import { action, makeObservable, observable } from 'mobx';
-import { hashValue, UnsupportedOperationError } from '@finos/legend-shared';
-import {
-  type PackageableElement,
-  Profile,
-  Enumeration,
-  Class,
-  Association,
-  Mapping,
-  ConcreteFunctionDefinition,
-  Service,
-  FlatData,
-  PackageableConnection,
-  PackageableRuntime,
-  JsonModelConnection,
-  XmlModelConnection,
-  FlatDataConnection,
-  FileGenerationSpecification,
-  GenerationSpecification,
-  Measure,
-  Database,
-  RelationalDatabaseConnection,
-  DataElement,
-  ModelChainConnection,
-  PURE_ELEMENT_NAME,
-  PURE_CONNECTION_NAME,
-  ExecutionEnvironmentInstance,
-} from '@finos/legend-graph';
-import { generatePackageableElementTreeNodeDataLabel } from '../utils/PackageTreeUtils.js';
+import { hashValue } from '@finos/legend-shared';
+import { type SourceInformation } from '@finos/legend-graph';
 import { LEGEND_STUDIO_SETTING_KEY } from '../../../__lib__/LegendStudioSetting.js';
 import type { CodeEditorPosition } from '@finos/legend-lego/code-editor';
-import type { DSL_Mapping_LegendStudioApplicationPlugin_Extension } from '../../extensions/DSL_Mapping_LegendStudioApplicationPlugin_Extension.js';
-import type { DSL_LegendStudioApplicationPlugin_Extension } from '../../LegendStudioApplicationPlugin.js';
 
-const getGrammarElementTypeLabelRegexString = (
-  typeLabel: string,
-  elementPath: string,
-): string =>
-  (
-    `^([^\\S\\n])*${typeLabel}` + // start with type label (accounted for spaces, but not newline)
-    `(\\s+<<.*>>)?` + // account for stereotype
-    `(\\s+\\{.*\\})?` + // account for tagged value
-    `\\s+${elementPath
-      .replaceAll('*', '\\*')
-      .replaceAll('(', '\\(')
-      .replaceAll(')', '\\)')
-      .replaceAll('[', '\\[')
-      .replaceAll(']', '\\]')}` + // element path (might contain [],(),*)
-    `[\\s\\n]`
-  ) // account for termination after element path
-    .replace(/\$/g, '\\$'); // replace special character $ by \\$
 export class GrammarTextEditorState {
   readonly editorStore: EditorStore;
 
+  sourceInformationIndex = new Map<string, SourceInformation>();
   graphGrammarText = '';
-  currentElementLabelRegexString?: string | undefined;
   wrapText: boolean;
+
   forcedCursorPosition?: CodeEditorPosition | undefined;
 
   constructor(editorStore: EditorStore) {
     makeObservable(this, {
       graphGrammarText: observable,
-      currentElementLabelRegexString: observable,
       wrapText: observable,
       forcedCursorPosition: observable,
       setGraphGrammarText: action,
       setWrapText: action,
       setForcedCursorPosition: action,
-      resetCurrentElementLabelRegexString: action,
-      setCurrentElementLabelRegexString: action,
     });
 
     this.editorStore = editorStore;
@@ -110,99 +63,7 @@ export class GrammarTextEditorState {
     this.forcedCursorPosition = position;
   }
 
-  resetCurrentElementLabelRegexString(): void {
-    this.currentElementLabelRegexString = undefined;
-  }
-
-  setCurrentElementLabelRegexString(element: PackageableElement): void {
-    let typeLabel: string | undefined;
-    if (element instanceof Class) {
-      typeLabel = PURE_ELEMENT_NAME.CLASS;
-    } else if (element instanceof Association) {
-      typeLabel = PURE_ELEMENT_NAME.ASSOCIATION;
-    } else if (element instanceof Enumeration) {
-      typeLabel = PURE_ELEMENT_NAME.ENUMERATION;
-    } else if (element instanceof Measure) {
-      typeLabel = PURE_ELEMENT_NAME.MEASURE;
-    } else if (element instanceof Profile) {
-      typeLabel = PURE_ELEMENT_NAME.PROFILE;
-    } else if (element instanceof ConcreteFunctionDefinition) {
-      typeLabel = PURE_ELEMENT_NAME.FUNCTION;
-    } else if (element instanceof FlatData) {
-      typeLabel = PURE_ELEMENT_NAME.FLAT_DATA;
-    } else if (element instanceof Database) {
-      typeLabel = PURE_ELEMENT_NAME.DATABASE;
-    } else if (element instanceof Mapping) {
-      typeLabel = PURE_ELEMENT_NAME.MAPPING;
-    } else if (element instanceof Service) {
-      typeLabel = PURE_ELEMENT_NAME.SERVICE;
-    } else if (element instanceof FileGenerationSpecification) {
-      typeLabel = PURE_ELEMENT_NAME.FILE_GENERATION;
-    } else if (element instanceof GenerationSpecification) {
-      typeLabel = PURE_ELEMENT_NAME.GENERATION_SPECIFICATION;
-    } else if (element instanceof PackageableConnection) {
-      if (element.connectionValue instanceof JsonModelConnection) {
-        typeLabel = PURE_CONNECTION_NAME.JSON_MODEL_CONNECTION;
-      } else if (element.connectionValue instanceof XmlModelConnection) {
-        typeLabel = PURE_CONNECTION_NAME.XML_MODEL_CONNECTION;
-      } else if (element.connectionValue instanceof FlatDataConnection) {
-        typeLabel = PURE_CONNECTION_NAME.FLAT_DATA_CONNECTION;
-      } else if (element.connectionValue instanceof ModelChainConnection) {
-        typeLabel = PURE_CONNECTION_NAME.MODEL_CHAIN_CONNECTION;
-      } else if (
-        element.connectionValue instanceof RelationalDatabaseConnection
-      ) {
-        typeLabel = PURE_CONNECTION_NAME.RELATIONAL_DATABASE_CONNECTION;
-      }
-      const extraPureGrammarConnectionLabelers = this.editorStore.pluginManager
-        .getApplicationPlugins()
-        .flatMap(
-          (plugin) =>
-            (
-              plugin as DSL_Mapping_LegendStudioApplicationPlugin_Extension
-            ).getExtraPureGrammarConnectionLabelers?.() ?? [],
-        );
-      for (const labeler of extraPureGrammarConnectionLabelers) {
-        const _typeLabel = labeler(element.connectionValue);
-        if (_typeLabel) {
-          typeLabel = _typeLabel;
-          break;
-        }
-      }
-    } else if (element instanceof PackageableRuntime) {
-      typeLabel = PURE_ELEMENT_NAME.RUNTIME;
-    } else if (element instanceof DataElement) {
-      typeLabel = PURE_ELEMENT_NAME.DATA_ELEMENT;
-    } else if (element instanceof ExecutionEnvironmentInstance) {
-      typeLabel = PURE_ELEMENT_NAME.EXECUTION_ENVIRONMENT;
-    } else {
-      const extraPureGrammarElementLabelers = this.editorStore.pluginManager
-        .getApplicationPlugins()
-        .flatMap(
-          (plugin) =>
-            (
-              plugin as DSL_LegendStudioApplicationPlugin_Extension
-            ).getExtraPureGrammarElementLabelers?.() ?? [],
-        );
-      for (const labeler of extraPureGrammarElementLabelers) {
-        const _typeLabel = labeler(element);
-        if (_typeLabel) {
-          typeLabel = _typeLabel;
-          break;
-        }
-      }
-    }
-    if (!typeLabel) {
-      throw new UnsupportedOperationError(
-        `Can't construct label for element type in Pure grammar: no compatible labeler available from plugins`,
-        element,
-      );
-    }
-    this.currentElementLabelRegexString = getGrammarElementTypeLabelRegexString(
-      typeLabel,
-      `${element.package?.path}::${generatePackageableElementTreeNodeDataLabel(
-        element,
-      )}`,
-    );
+  setSourceInformationIndex(val: Map<string, SourceInformation>): void {
+    this.sourceInformationIndex = val;
   }
 }

package/src/stores/editor/editor-state/element-editor-state/connection/ConnectionEditorState.ts

@@ -23,7 +23,6 @@ import {
 } from '@finos/legend-shared';
 import { ElementEditorState } from './../ElementEditorState.js';
 import type { STO_Relational_LegendStudioApplicationPlugin_Extension } from '../../../../extensions/STO_Relational_LegendStudioApplicationPlugin_Extension.js';
-import { DatabaseBuilderState } from './DatabaseBuilderState.js';
 import {
   type PackageableElement,
   type Connection,
@@ -119,7 +118,6 @@ export enum CORE_AUTHENTICATION_STRATEGY_TYPE {
 export class RelationalDatabaseConnectionValueState extends ConnectionValueState {
   override connection: RelationalDatabaseConnection;
   selectedTab = RELATIONAL_DATABASE_TAB_TYPE.GENERAL;
-  databaseBuilderState: DatabaseBuilderState;
   postProcessorState: PostProcessorEditorState | undefined;
 
   constructor(
@@ -128,19 +126,15 @@ export class RelationalDatabaseConnectionValueState extends ConnectionValueState
   ) {
     super(editorStore, connection);
     makeObservable(this, {
-      databaseBuilderState: observable,
       selectedTab: observable,
       postProcessorState: observable,
+      selectedDatasourceSpecificationType: computed,
+      selectedAuthenticationStrategyType: computed,
       setSelectedTab: action,
       selectPostProcessor: action,
     });
 
     this.connection = connection;
-
-    this.databaseBuilderState = new DatabaseBuilderState(
-      editorStore,
-      connection,
-    );
   }
 
   selectPostProcessor = (postProcessor: PostProcessor | undefined): void => {
@@ -186,7 +180,7 @@ export class RelationalDatabaseConnectionValueState extends ConnectionValueState
     return `${this.connection.type} connection`;
   }
 
-  get selectedDatasourceSpec(): string {
+  get selectedDatasourceSpecificationType(): string | undefined {
     const spec = this.connection.datasourceSpecification;
     if (spec instanceof StaticDatasourceSpecification) {
       return CORE_DATASOURCE_SPEC_TYPE.STATIC;
@@ -222,10 +216,7 @@ export class RelationalDatabaseConnectionValueState extends ConnectionValueState
         return type;
       }
     }
-    throw new UnsupportedOperationError(
-      `Can't classify datasource specification: no compatible classifer available from plugins`,
-      spec,
-    );
+    return undefined;
   }
 
   changeDatasourceSpec(type: string): void {
@@ -310,7 +301,8 @@ export class RelationalDatabaseConnectionValueState extends ConnectionValueState
       observerContext,
     );
   }
-  get selectedAuth(): string {
+
+  get selectedAuthenticationStrategyType(): string | undefined {
     const auth = this.connection.authenticationStrategy;
     if (auth instanceof DelegatedKerberosAuthenticationStrategy) {
       return CORE_AUTHENTICATION_STRATEGY_TYPE.DELEGATED_KERBEROS;
@@ -355,10 +347,8 @@ export class RelationalDatabaseConnectionValueState extends ConnectionValueState
         return type;
       }
     }
-    throw new UnsupportedOperationError(
-      `Can't classify authentication strategy: no compatible classifier available from plugins`,
-      auth,
-    );
+
+    return undefined;
   }
 
   changeAuthenticationStrategy(type: string): void {

package/src/stores/editor/editor-state/element-editor-state/connection/DatabaseBuilderState.ts

@@ -28,14 +28,16 @@ import {
   isNonNullable,
   filterByType,
   ActionState,
+  guaranteeType,
 } from '@finos/legend-shared';
 import { observable, action, makeObservable, flow, flowResult } from 'mobx';
 import { LEGEND_STUDIO_APP_EVENT } from '../../../../../__lib__/LegendStudioEvent.js';
 import type { EditorStore } from '../../../EditorStore.js';
 import {
-  type RelationalDatabaseConnection,
   type Schema,
+  type PackageableElement,
   type Table,
+  RelationalDatabaseConnection,
   DatabaseBuilderInput,
   DatabasePattern,
   TargetDatabase,
@@ -48,10 +50,19 @@ import {
   getSchema,
   getNullableSchema,
   getNullableTable,
+  PackageableConnection,
 } from '@finos/legend-graph';
 import { connection_setStore } from '../../../../graph-modifier/DSL_Mapping_GraphModifierHelper.js';
 import { GraphEditFormModeState } from '../../../GraphEditFormModeState.js';
 
+export const guaranteeRelationalDatabaseConnection = (
+  val: PackageableElement | undefined,
+): RelationalDatabaseConnection =>
+  guaranteeType(
+    guaranteeType(val, PackageableConnection).connectionValue,
+    RelationalDatabaseConnection,
+  );
+
 export abstract class DatabaseBuilderTreeNodeData implements TreeNodeData {
   isOpen?: boolean | undefined;
   id: string;
@@ -108,10 +119,12 @@ export class DatabaseBuilderState {
   isSavingDatabase = false;
   targetDatabasePath: string;
   treeData?: DatabaseBuilderTreeData | undefined;
+  isReadOnly: boolean;
 
   constructor(
     editorStore: EditorStore,
     connection: RelationalDatabaseConnection,
+    isReadOnly: boolean,
   ) {
     makeObservable<
       DatabaseBuilderState,
@@ -140,6 +153,7 @@ export class DatabaseBuilderState {
     this.connection = connection;
     this.editorStore = editorStore;
     this.targetDatabasePath = this.currentDatabase?.path ?? 'store::MyDatabase';
+    this.isReadOnly = isReadOnly;
   }
 
   setShowModal(val: boolean): void {
@@ -578,9 +592,7 @@ export class DatabaseBuilderState {
         const schemas = this.getSchemasFromTreeNode(this.treeData);
         this.updateDatabase(currentDatabase, database, schemas);
         this.editorStore.applicationStore.notificationService.notifySuccess(
-          `Database successfully '${isUpdating ? 'updated' : 'created'}. ${
-            !isUpdating ? 'Recompiling...' : ''
-          }`,
+          `Database successfully '${isUpdating ? 'updated' : 'created'}.`,
         );
         this.fetchSchemaDefinitions();
         if (isUpdating) {
@@ -593,6 +605,7 @@ export class DatabaseBuilderState {
           );
         }
       }
+      this.setShowModal(false);
     } catch (error) {
       assertErrorThrown(error);
       this.editorStore.applicationStore.logService.error(

package/src/stores/editor/editor-state/element-editor-state/data/DataEditorState.ts

@@ -40,13 +40,10 @@ export type EmbeddedDataTypeOption = {
 };
 
 export class EmbeddedDataEditorState {
-  /**
-   * NOTE: used to force component remount on state change
-   */
   readonly uuid = uuid();
-  editorStore: EditorStore;
-  embeddedData: EmbeddedData;
-  embeddedDataState: EmbeddedDataState;
+  readonly editorStore: EditorStore;
+  readonly embeddedData: EmbeddedData;
+  readonly embeddedDataState: EmbeddedDataState;
 
   constructor(editorStore: EditorStore, embeddedData: EmbeddedData) {
     this.editorStore = editorStore;
@@ -59,7 +56,8 @@ export class EmbeddedDataEditorState {
 }
 
 export class PackageableDataEditorState extends ElementEditorState {
-  embeddedDataState: EmbeddedDataEditorState;
+  readonly embeddedDataState: EmbeddedDataEditorState;
+
   selectedTab = DATA_TAB_TYPE.GENERAL;
 
   constructor(editorStore: EditorStore, element: PackageableElement) {