@finos/legend-application-studio 26.1.11 → 27.1.0

package/src/components/editor/side-bar/CreateNewElementModal.tsx

@@ -81,6 +81,8 @@ export const getElementTypeLabel = (
       return 'generation specification';
     case PACKAGEABLE_ELEMENT_TYPE.DATA:
       return 'data';
+    case PACKAGEABLE_ELEMENT_TYPE.TEMPORARY__LOCAL_CONNECTION:
+      return 'local connection';
     default: {
       if (type) {
         const extraElementTypeLabelGetters = editorStore.pluginManager
@@ -436,7 +438,115 @@ const renderNewElementDriver = (
   }
 };
 
-// TODO: investigate the potential approach of VSCode to have inline input in the tree to create element quickly
+export const CreateNewLocalConnectionModal = observer(() => {
+  const editorStore = useEditorStore();
+  const applicationStore = useApplicationStore();
+  const newElementState = editorStore.newElementState;
+  const selectedPackage = newElementState.selectedPackage;
+  // Name
+  const name = newElementState.name;
+  const handleNameChange: React.ChangeEventHandler<HTMLInputElement> = (
+    event,
+  ) => newElementState.setName(event.target.value);
+  const elementNameInputRef = useRef<HTMLInputElement>(null);
+  // Type
+  const typeOptions = ([PACKAGEABLE_ELEMENT_TYPE.PACKAGE] as string[])
+    .concat(editorStore.getSupportedElementTypes())
+    .filter(
+      // NOTE: we can only create package in root
+      (type) =>
+        selectedPackage !== editorStore.graphManagerState.graph.root ||
+        type === PACKAGEABLE_ELEMENT_TYPE.PACKAGE,
+    )
+    .map(buildElementTypeOption);
+
+  const selectedTypeOption = buildElementTypeOption(newElementState.type);
+  const handleTypeChange = (val: ElementTypeSelectOption): void =>
+    newElementState.setElementType(val.value);
+  // Submit button
+  const closeModal = (): void => newElementState.closeModal();
+  const [packagePath, elementName] = resolvePackageAndElementName(
+    selectedPackage,
+    selectedPackage === editorStore.graphManagerState.graph.root,
+    name,
+  );
+  const resolvedPackage =
+    editorStore.graphManagerState.graph.getNullablePackage(packagePath);
+  const needsToOverride = Boolean(
+    resolvedPackage?.children.find((child) => child.name === elementName),
+  );
+  const isDisabled = !name || needsToOverride || !newElementState.isValid;
+  const save = applicationStore.guardUnhandledError(() =>
+    flowResult(newElementState.save()),
+  );
+  const handleEnter = (): void => {
+    newElementState.setName('');
+    elementNameInputRef.current?.focus();
+  };
+
+  if (!newElementState.showModal) {
+    return null;
+  }
+  return (
+    <Dialog
+      open={newElementState.showModal}
+      onClose={closeModal}
+      TransitionProps={{
+        onEnter: handleEnter,
+      }}
+      classes={{ container: 'search-modal__container' }}
+      PaperProps={{ classes: { root: 'search-modal__inner-container' } }}
+    >
+      <form
+        data-testid={LEGEND_STUDIO_TEST_ID.NEW_ELEMENT_MODAL}
+        onSubmit={(event) => {
+          event.preventDefault();
+          save();
+        }}
+        className="modal modal--dark search-modal"
+      >
+        <div className="modal__title">
+          {`Create a New ${
+            getElementTypeLabel(editorStore, newElementState.type) ?? 'element'
+          }`}
+        </div>
+        <div>
+          {newElementState.showType && (
+            <CustomSelectorInput
+              options={typeOptions}
+              disabled={typeOptions.length === 1}
+              onChange={handleTypeChange}
+              value={selectedTypeOption}
+              isClearable={false}
+              darkMode={true}
+            />
+          )}
+          <input
+            className="input--dark explorer__new-element-modal__name-input"
+            ref={elementNameInputRef}
+            spellCheck={false}
+            value={name}
+            onChange={handleNameChange}
+            placeholder={`Enter a name, use ${ELEMENT_PATH_DELIMITER} to create new package(s) for the ${
+              getElementTypeLabel(editorStore, newElementState.type) ??
+              'element'
+            }`}
+          />
+          {renderNewElementDriver(newElementState.type, editorStore)}
+        </div>
+        <div className="search-modal__actions">
+          <button type="button" className="btn btn--dark" onClick={closeModal}>
+            Cancel
+          </button>
+          <button className="btn btn--dark" disabled={isDisabled}>
+            Create
+          </button>
+        </div>
+      </form>
+    </Dialog>
+  );
+});
+
 export const CreateNewElementModal = observer(() => {
   const editorStore = useEditorStore();
   const applicationStore = useApplicationStore();

package/src/components/editor/side-bar/testable/GlobalTestRunner.tsx

@@ -54,7 +54,6 @@ import {
   type GeneratorFn,
   isNonNullable,
   prettyCONSTName,
-  toTitleCase,
 } from '@finos/legend-shared';
 import { observer } from 'mobx-react-lite';
 import { forwardRef, useEffect, useState } from 'react';
@@ -429,23 +428,28 @@ export const GlobalTestRunner = observer(
     const editorStore = useEditorStore();
     const globalTestRunnerState = props.globalTestRunnerState;
     const isDispatchingAction = globalTestRunnerState.isDispatchingAction;
-    const testRunnerTabs = (Object.values(TEST_RUNNER_TABS) as string[])
-      .concat(
-        editorStore.pluginManager
-          .getApplicationPlugins()
-          .flatMap(
-            (plugin) => plugin.getExtraTestRunnerTabClassifiers?.() ?? [],
-          ),
-      )
-      .map((e) => ({
-        value: e,
-        label: prettyCONSTName(e),
-      }));
 
     const [selectedTab, setSelectedTab] = useState(
       TEST_RUNNER_TABS.TEST_RUNNER.valueOf(),
     );
 
+    const extractTestRunnerTabConfigurations = editorStore.pluginManager
+      .getApplicationPlugins()
+      .flatMap((plugin) => plugin.getExtraTestRunnerTabConfigurations?.() ?? [])
+      .filter((configuration) => configuration.renderer(editorStore));
+
+    const testRunnerTabs = (Object.values(TEST_RUNNER_TABS) as string[])
+      .map((e) => ({
+        value: e,
+        label: prettyCONSTName(e),
+      }))
+      .concat(
+        extractTestRunnerTabConfigurations.map((config) => ({
+          value: config.key,
+          label: config.title,
+        })),
+      );
+
     const changeTab = (tab: string): void => {
       setSelectedTab(tab);
     };
@@ -544,7 +548,7 @@ export const GlobalTestRunner = observer(
                     ['panel__header__tab--active']: tab.value === selectedTab,
                   })}
                 >
-                  {toTitleCase(prettyCONSTName(tab.value))}
+                  {tab.label}
                 </div>
               ))}
             </div>
@@ -578,15 +582,9 @@ export const GlobalTestRunner = observer(
           </div>
         );
       } else {
-        const extraTestRunnerTabEditorRenderers = editorStore.pluginManager
-          .getApplicationPlugins()
-          .flatMap(
-            (plugin) => plugin.getExtraTestRunnerTabEditorRenderers?.() ?? [],
-          );
-        for (const editorRenderer of extraTestRunnerTabEditorRenderers) {
-          const editor = editorRenderer(selectedTab, editorStore);
-          if (editor) {
-            return editor;
+        for (const testRunnerTabConfiguration of extractTestRunnerTabConfigurations) {
+          if (testRunnerTabConfiguration.key === selectedTab) {
+            return testRunnerTabConfiguration.renderer(editorStore);
           }
         }
         return (

package/src/components/extensions/Core_LegendStudioApplicationPlugin.tsx

@@ -133,6 +133,16 @@ export class Core_LegendStudioApplicationPlugin extends LegendStudioApplicationP
       LEGEND_STUDIO_APPLICATION_NAVIGATION_CONTEXT_KEY.CONNECTION_EDITOR,
       LEGEND_STUDIO_APPLICATION_NAVIGATION_CONTEXT_KEY.DATABASE_BUILDER,
       LEGEND_STUDIO_APPLICATION_NAVIGATION_CONTEXT_KEY.SERVICE_EDITOR,
+      LEGEND_STUDIO_APPLICATION_NAVIGATION_CONTEXT_KEY.DATA_ELEMENT_EDITOR,
+      LEGEND_STUDIO_APPLICATION_NAVIGATION_CONTEXT_KEY.MAPPING_EDITOR,
+      LEGEND_STUDIO_APPLICATION_NAVIGATION_CONTEXT_KEY.RUNTIME_EDITOR,
+      LEGEND_STUDIO_APPLICATION_NAVIGATION_CONTEXT_KEY.BINDING_EDITOR,
+      LEGEND_STUDIO_APPLICATION_NAVIGATION_CONTEXT_KEY.SCHEMA_SET_EDITOR,
+      LEGEND_STUDIO_APPLICATION_NAVIGATION_CONTEXT_KEY.SCHEMA_SET_MODEL_GENERATION,
+      LEGEND_STUDIO_APPLICATION_NAVIGATION_CONTEXT_KEY.EMBEDDED_DATA_RELATIONAL_EDITOR,
+      LEGEND_STUDIO_APPLICATION_NAVIGATION_CONTEXT_KEY.EMBEDDED_DATA_EXTERNAL_FORMAT_EDITOR,
+      LEGEND_STUDIO_APPLICATION_NAVIGATION_CONTEXT_KEY.EMBEDDED_DATA_DATA_ELEMENT_REFERENCE_EDITOR,
+      LEGEND_STUDIO_APPLICATION_NAVIGATION_CONTEXT_KEY.EMBEDDED_DATA_MODEL_STORE_EDITOR,
     ];
   }
 

package/src/stores/LegendStudioApplicationPlugin.ts

@@ -77,10 +77,11 @@ export type TestableMetadataGetter = (
   editorStore: EditorStore,
 ) => TestableMetadata | undefined;
 
-export type TestRunnerTabRenderer = (
-  selectedTab: string,
-  editorStore: EditorStore,
-) => React.ReactNode | undefined;
+export type TestRunnerTabConfiguration = {
+  key: string;
+  title: string;
+  renderer: (editorStore: EditorStore) => React.ReactNode | undefined;
+};
 
 export abstract class LegendStudioApplicationPlugin extends LegendApplicationPlugin {
   /**
@@ -126,14 +127,9 @@ export abstract class LegendStudioApplicationPlugin extends LegendApplicationPlu
   getExtraTestableMetadata?(): TestableMetadataGetter[];
 
   /**
-   * Get the list of the supported classifers for test runner tabs.
-   */
-  getExtraTestRunnerTabClassifiers?(): string[];
-
-  /**
-   * Get the list of renderers for the editor for a test runner tab.
+   * Get the list of configurations for the editor for a test runner tab.
    */
-  getExtraTestRunnerTabEditorRenderers?(): TestRunnerTabRenderer[];
+  getExtraTestRunnerTabConfigurations?(): TestRunnerTabConfiguration[];
 }
 
 export type PureGrammarElementLabeler = (

package/src/stores/editor/EditorGraphState.ts

@@ -860,6 +860,6 @@ export class EditorGraphState {
         return label;
       }
     }
-    return PACKAGEABLE_ELEMENT_TYPE.UNKNOWN;
+    return PACKAGEABLE_ELEMENT_TYPE.INTERNAL__UNKNOWN;
   }
 }

package/src/stores/editor/EditorStore.ts

@@ -929,25 +929,37 @@ export class EditorStore implements CommandRegistrar {
         PACKAGEABLE_ELEMENT_TYPE.ASSOCIATION,
         PACKAGEABLE_ELEMENT_TYPE.FUNCTION,
         PACKAGEABLE_ELEMENT_TYPE.MEASURE,
-        PACKAGEABLE_ELEMENT_TYPE.MAPPING,
-        PACKAGEABLE_ELEMENT_TYPE.RUNTIME,
-        PACKAGEABLE_ELEMENT_TYPE.CONNECTION,
-        PACKAGEABLE_ELEMENT_TYPE.SERVICE,
-        PACKAGEABLE_ELEMENT_TYPE.GENERATION_SPECIFICATION,
-        PACKAGEABLE_ELEMENT_TYPE.FILE_GENERATION,
-        PACKAGEABLE_ELEMENT_TYPE.FLAT_DATA_STORE,
-        PACKAGEABLE_ELEMENT_TYPE.DATABASE,
-        PACKAGEABLE_ELEMENT_TYPE.DATA,
       ] as string[]
     ).concat(
-      this.pluginManager
-        .getApplicationPlugins()
-        .flatMap(
-          (plugin) =>
-            (
-              plugin as DSL_LegendStudioApplicationPlugin_Extension
-            ).getExtraSupportedElementTypes?.() ?? [],
-        ),
+      (
+        [
+          PACKAGEABLE_ELEMENT_TYPE.MAPPING,
+          PACKAGEABLE_ELEMENT_TYPE.RUNTIME,
+          PACKAGEABLE_ELEMENT_TYPE.CONNECTION,
+          PACKAGEABLE_ELEMENT_TYPE.SERVICE,
+          PACKAGEABLE_ELEMENT_TYPE.GENERATION_SPECIFICATION,
+          PACKAGEABLE_ELEMENT_TYPE.FILE_GENERATION,
+          PACKAGEABLE_ELEMENT_TYPE.FLAT_DATA_STORE,
+          PACKAGEABLE_ELEMENT_TYPE.DATABASE,
+          PACKAGEABLE_ELEMENT_TYPE.DATA,
+          this.applicationStore.config.options
+            .TEMPORARY__enableLocalConnectionBuilder
+            ? PACKAGEABLE_ELEMENT_TYPE.TEMPORARY__LOCAL_CONNECTION
+            : undefined,
+        ] as (string | undefined)[]
+      )
+        .filter(isNonNullable)
+        .concat(
+          this.pluginManager
+            .getApplicationPlugins()
+            .flatMap(
+              (plugin) =>
+                (
+                  plugin as DSL_LegendStudioApplicationPlugin_Extension
+                ).getExtraSupportedElementTypes?.() ?? [],
+            ),
+        )
+        .sort((a, b) => a.localeCompare(b)),
     );
   }
 

package/src/stores/editor/GraphEditFormModeState.ts

@@ -578,7 +578,6 @@ export class GraphEditFormModeState extends GraphEditorMode {
 
   *onLeave(): GeneratorFn<void> {
     this.editorStore.sqlPlaygroundState.setConnection(undefined);
-    return;
   }
 
   *cleanupBeforeEntering(fallbackOptions?: {

package/src/stores/editor/NewElementState.ts

@@ -66,7 +66,6 @@ import {
   PackageableElementExplicitReference,
   RelationalDatabaseConnection,
   DatabaseType,
-  StaticDatasourceSpecification,
   DefaultH2AuthenticationStrategy,
   ModelGenerationSpecification,
   DataElement,
@@ -74,6 +73,13 @@ import {
   Measure,
   Multiplicity,
   PrimitiveType,
+  LocalH2DatasourceSpecification,
+  SnowflakeDatasourceSpecification,
+  SnowflakePublicAuthenticationStrategy,
+  StoreConnections,
+  ConnectionPointer,
+  IdentifiedConnection,
+  generateIdentifiedConnectionId,
 } from '@finos/legend-graph';
 import type { DSL_Mapping_LegendStudioApplicationPlugin_Extension } from '../extensions/DSL_Mapping_LegendStudioApplicationPlugin_Extension.js';
 import {
@@ -302,6 +308,8 @@ export class NewFlatDataConnectionDriver extends NewConnectionValueDriver<FlatDa
   }
 }
 
+const DEFAULT_H2_SQL =
+  '-- loads sample data for getting started. See https://github.com/pthom/northwind_psql for more info\n call loadNorthwindData()';
 export class NewRelationalDatabaseConnectionDriver extends NewConnectionValueDriver<RelationalDatabaseConnection> {
   constructor(editorStore: EditorStore) {
     super(editorStore);
@@ -327,10 +335,12 @@ export class NewRelationalDatabaseConnectionDriver extends NewConnectionValueDri
       const dbs = this.editorStore.graphManagerState.usableDatabases;
       selectedStore = dbs.length ? (dbs[0] as Database) : stub_Database();
     }
+    const spec = new LocalH2DatasourceSpecification();
+    spec.testDataSetupSqls = [DEFAULT_H2_SQL];
     return new RelationalDatabaseConnection(
       PackageableElementExplicitReference.create(selectedStore),
       DatabaseType.H2,
-      new StaticDatasourceSpecification('dummyHost', 80, 'myDb'),
+      spec,
       new DefaultH2AuthenticationStrategy(),
     );
   }
@@ -440,7 +450,6 @@ export class NewPackageableConnectionDriver extends NewElementDriver<Packageable
       this.store = store;
       this.newConnectionValueDriver = newDriver;
     }
-    return;
   }
 
   get isValid(): boolean {
@@ -643,7 +652,6 @@ export class NewElementState {
       _package: observable,
       name: observable,
       newElementDriver: observable,
-      elementAndPackageName: computed,
       selectedPackage: computed,
       isValid: computed,
       setShowModal: action,
@@ -662,14 +670,6 @@ export class NewElementState {
     this.type = PACKAGEABLE_ELEMENT_TYPE.PACKAGE;
   }
 
-  get elementAndPackageName(): [string, string] {
-    return resolvePackageAndElementName(
-      this.selectedPackage,
-      this._package === this.editorStore.graphManagerState.graph.root,
-      this.name,
-    );
-  }
-
   get selectedPackage(): Package {
     return this._package
       ? this._package
@@ -775,7 +775,11 @@ export class NewElementState {
 
   *save(): GeneratorFn<void> {
     if (this.name && this.isValid) {
-      const [packagePath, elementName] = this.elementAndPackageName;
+      const [packagePath, elementName] = resolvePackageAndElementName(
+        this.selectedPackage,
+        this._package === this.editorStore.graphManagerState.graph.root,
+        this.name,
+      );
       if (
         this.editorStore.graphManagerState.graph.getNullablePackage(
           packagePath,
@@ -786,17 +790,105 @@ export class NewElementState {
           `Can't create elements for type other than 'package' in root package`,
         );
       } else {
-        const element = this.createElement(elementName);
-        yield flowResult(
-          this.editorStore.graphEditorMode.addElement(
-            element,
-            packagePath,
-            true,
-          ),
-        );
+        if (
+          this.editorStore.applicationStore.config.options
+            .TEMPORARY__enableLocalConnectionBuilder &&
+          this.type === PACKAGEABLE_ELEMENT_TYPE.TEMPORARY__LOCAL_CONNECTION
+        ) {
+          // NOTE: this is temporary until we have proper support for local connection
+          // For now, we aim to fulfill the PoC for SnowflakeApp use case and will generate
+          // everything: mapping, store, connection, runtime, etc.
+          const store = new Database(`${this.name}_Database`);
+          const mapping = new Mapping(`${this.name}_Mapping`);
+          // connection
+          const connection = new PackageableConnection(
+            `${this.name}_LocalConnection`,
+          );
+          const _suffix = `${packagePath.replaceAll(
+            ELEMENT_PATH_DELIMITER,
+            '-',
+          )}-${connection.name}`;
+          const datasourceSpecification = new SnowflakeDatasourceSpecification(
+            `legend-local-snowflake-accountName-${_suffix}`,
+            `legend-local-snowflake-region-${_suffix}`,
+            `legend-local-snowflake-warehouseName-${_suffix}`,
+            `legend-local-snowflake-databaseName-${_suffix}`,
+          );
+          datasourceSpecification.cloudType = `legend-local-snowflake-cloudType-${_suffix}`;
+          datasourceSpecification.role = `legend-local-snowflake-role-${_suffix}`;
+          const connectionValue = new RelationalDatabaseConnection(
+            PackageableElementExplicitReference.create(store),
+            DatabaseType.Snowflake,
+            datasourceSpecification,
+            new SnowflakePublicAuthenticationStrategy(
+              `legend-local-snowflake-privateKeyVaultReference-${_suffix}`,
+              `legend-local-snowflake-passphraseVaultReference-${_suffix}`,
+              `legend-local-snowflake-publicuserName-${_suffix}`,
+            ),
+          );
+          connectionValue.localMode = true;
+          connection.connectionValue = connectionValue;
+          // runtime
+          const runtime = new PackageableRuntime(`${this.name}_Runtime`);
+          const engineRuntime = new EngineRuntime();
+          engineRuntime.mappings = [
+            PackageableElementExplicitReference.create(mapping),
+          ];
+          const storeConnections = new StoreConnections(
+            PackageableElementExplicitReference.create(store),
+          );
+          storeConnections.storeConnections = [
+            new IdentifiedConnection(
+              generateIdentifiedConnectionId(engineRuntime),
+              new ConnectionPointer(
+                PackageableElementExplicitReference.create(connection),
+              ),
+            ),
+          ];
+          engineRuntime.connections = [storeConnections];
+          runtime.runtimeValue = engineRuntime;
+          // add the elements
+          yield flowResult(
+            this.editorStore.graphEditorMode.addElement(
+              store,
+              packagePath,
+              false,
+            ),
+          );
+          yield flowResult(
+            this.editorStore.graphEditorMode.addElement(
+              connection,
+              packagePath,
+              false,
+            ),
+          );
+          yield flowResult(
+            this.editorStore.graphEditorMode.addElement(
+              mapping,
+              packagePath,
+              false,
+            ),
+          );
+          yield flowResult(
+            this.editorStore.graphEditorMode.addElement(
+              runtime,
+              packagePath,
+              false,
+            ),
+          );
+        } else {
+          const element = this.createElement(elementName);
+          yield flowResult(
+            this.editorStore.graphEditorMode.addElement(
+              element,
+              packagePath,
+              true,
+            ),
+          );
 
-        // post creation handling
-        yield handlePostCreateAction(element, this.editorStore);
+          // post creation handling
+          yield handlePostCreateAction(element, this.editorStore);
+        }
       }
     }
     this.closeModal();

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

@@ -146,8 +146,8 @@ export class DatabaseBuilderState {
     makeObservable<DatabaseBuilderState>(this, {
       showModal: observable,
       targetDatabasePath: observable,
-      isBuildingDatabase: observable,
       databaseGrammarCode: observable,
+      isBuildingDatabase: observable,
       isSavingDatabase: observable,
       currentDatabase: computed,
       setTargetDatabasePath: action,
@@ -219,7 +219,7 @@ export class DatabaseBuilderState {
     treeData: DatabaseBuilderTreeData,
   ): DatabaseBuilderTreeNodeData[] | undefined {
     return node.childrenIds
-      ?.map((n) => treeData.nodes.get(n))
+      ?.map((childNode) => treeData.nodes.get(childNode))
       .filter(isNonNullable);
   }
 
@@ -245,7 +245,8 @@ export class DatabaseBuilderState {
         }
       }
     }
-    // TODO: handle ColumnDatabaseBuilderTreeNodeData
+
+    // TODO: support toggling check for columns
     this.setTreeData({ ...treeData });
   }
 
@@ -279,6 +280,7 @@ export class DatabaseBuilderState {
             schemaId,
             schema,
           );
+          nodes.set(schemaId, schemaNode);
 
           schemaNode.setChecked(
             Boolean(
@@ -287,7 +289,6 @@ export class DatabaseBuilderState {
               ),
             ),
           );
-          nodes.set(schemaId, schemaNode);
         });
       const treeData = { rootIds, nodes, database };
       this.setTreeData(treeData);
@@ -341,6 +342,8 @@ export class DatabaseBuilderState {
             schema,
             table,
           );
+          treeData.nodes.set(tableId, tableNode);
+          addUniqueEntry(childrenIds, tableId);
 
           if (this.currentDatabase) {
             const matchingSchema = getNullableSchema(
@@ -357,9 +360,6 @@ export class DatabaseBuilderState {
           } else {
             tableNode.setChecked(false);
           }
-
-          treeData.nodes.set(tableId, tableNode);
-          addUniqueEntry(childrenIds, tableId);
         });
       schemaNode.childrenIds = childrenIds;
       this.setTreeData({ ...treeData });
@@ -605,6 +605,8 @@ export class DatabaseBuilderState {
       } else {
         currentDatabase = this.currentDatabase;
       }
+
+      // remove undefined schemas
       const schemas = Array.from(this.treeData.nodes.values())
         .map((schemaNode) => {
           if (schemaNode instanceof SchemaDatabaseBuilderTreeNodeData) {
@@ -613,11 +615,32 @@ export class DatabaseBuilderState {
           return undefined;
         })
         .filter(isNonNullable);
-      this.updateDatabase(currentDatabase, database, schemas);
+      currentDatabase.schemas = currentDatabase.schemas.filter((schema) => {
+        if (
+          schemas.find((item) => item.name === schema.name) &&
+          !database.schemas.find((s) => s.name === schema.name)
+        ) {
+          return false;
+        }
+        return true;
+      });
+
+      // update existing schemas
+      database.schemas.forEach((schema) => {
+        (schema as Writable<Schema>)._OWNER = currentDatabase;
+        const currentSchemaIndex = currentDatabase.schemas.findIndex(
+          (item) => item.name === schema.name,
+        );
+        if (currentSchemaIndex !== -1) {
+          currentDatabase.schemas[currentSchemaIndex] = schema;
+        } else {
+          currentDatabase.schemas.push(schema);
+        }
+      });
+
       this.editorStore.applicationStore.notificationService.notifySuccess(
-        `Database successfully '${isUpdating ? 'updated' : 'created'}.`,
+        `Database successfully '${isUpdating ? 'updated' : 'created'}`,
       );
-      this.fetchDatabaseMetadata();
       if (isUpdating) {
         yield flowResult(
           this.editorStore
@@ -639,34 +662,4 @@ export class DatabaseBuilderState {
       this.isSavingDatabase = false;
     }
   }
-
-  updateDatabase(
-    current: Database,
-    generatedDatabase: Database,
-    allSchemas: Schema[],
-  ): void {
-    // remove undefined schemas
-    current.schemas = current.schemas.filter((schema) => {
-      if (
-        allSchemas.find((item) => item.name === schema.name) &&
-        !generatedDatabase.schemas.find((c) => c.name === schema.name)
-      ) {
-        return false;
-      }
-      return true;
-    });
-
-    // update existing schemas
-    generatedDatabase.schemas.forEach((schema) => {
-      (schema as Writable<Schema>)._OWNER = current;
-      const currentSchemaIndex = current.schemas.findIndex(
-        (item) => item.name === schema.name,
-      );
-      if (currentSchemaIndex !== -1) {
-        current.schemas[currentSchemaIndex] = schema;
-      } else {
-        current.schemas.push(schema);
-      }
-    });
-  }
 }

package/src/stores/editor/editor-state/element-editor-state/mapping/MappingEditorState.ts

@@ -121,7 +121,6 @@ import {
   setImpl_updateRootOnCreate,
   setImpl_updateRootOnDelete,
 } from '../../../../graph-modifier/DSL_Mapping_GraphModifierHelper.js';
-import { BASIC_SET_IMPLEMENTATION_TYPE } from '../../../utils/ModelClassifierUtils.js';
 import { rootRelationalSetImp_setMainTableAlias } from '../../../../graph-modifier/STO_Relational_GraphModifierHelper.js';
 import { LambdaEditorState } from '@finos/legend-query-builder';
 import type { MappingEditorTabState } from './MappingTabManagerState.js';
@@ -163,6 +162,11 @@ export enum MAPPING_ELEMENT_TYPE {
   ASSOCIATION = 'ASSOCIATION',
 }
 
+export enum BASIC_SET_IMPLEMENTATION_TYPE {
+  OPERATION = 'operation',
+  INSTANCE = 'instance',
+}
+
 export type MappingElement =
   | EnumerationMapping
   | SetImplementation