@finos/legend-application-studio 28.1.2 → 28.1.4

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

@@ -28,8 +28,17 @@ import {
   ActionState,
   getNonNullableEntry,
   guaranteeType,
+  assertNonEmptyString,
+  assertTrue,
 } from '@finos/legend-shared';
-import { observable, action, makeObservable, flow, flowResult } from 'mobx';
+import {
+  observable,
+  action,
+  makeObservable,
+  flow,
+  flowResult,
+  computed,
+} from 'mobx';
 import { LEGEND_STUDIO_APP_EVENT } from '../../../../../__lib__/LegendStudioEvent.js';
 import type { EditorStore } from '../../../EditorStore.js';
 import {
@@ -45,8 +54,12 @@ import {
   getSchema,
   getNullableSchema,
   getNullableTable,
+  isStubbed_PackageableElement,
+  isValidFullPath,
+  PackageableElementExplicitReference,
 } from '@finos/legend-graph';
 import { GraphEditFormModeState } from '../../../GraphEditFormModeState.js';
+import { connection_setStore } from '../../../../graph-modifier/DSL_Mapping_GraphModifierHelper.js';
 
 export abstract class DatabaseSchemaExplorerTreeNodeData
   implements TreeNodeData
@@ -114,10 +127,13 @@ export interface DatabaseExplorerTreeData
   database: Database;
 }
 
+const DEFAULT_DATABASE_PATH = 'store::MyDatabase';
+
 export class DatabaseSchemaExplorerState {
   readonly editorStore: EditorStore;
   readonly connection: RelationalDatabaseConnection;
   readonly database: Database;
+  targetDatabasePath: string;
 
   isGeneratingDatabase = false;
   isUpdatingDatabase = false;
@@ -131,7 +147,11 @@ export class DatabaseSchemaExplorerState {
       isGeneratingDatabase: observable,
       isUpdatingDatabase: observable,
       treeData: observable,
+      targetDatabasePath: observable,
+      isCreatingNewDatabase: computed,
+      resolveDatabasePackageAndName: computed,
       setTreeData: action,
+      setTargetDatabasePath: action,
       onNodeSelect: flow,
       fetchDatabaseMetadata: flow,
       fetchSchemaMetadata: flow,
@@ -143,6 +163,33 @@ export class DatabaseSchemaExplorerState {
     this.connection = connection;
     this.database = guaranteeType(connection.store.value, Database);
     this.editorStore = editorStore;
+    this.targetDatabasePath = DEFAULT_DATABASE_PATH;
+  }
+
+  get isCreatingNewDatabase(): boolean {
+    return isStubbed_PackageableElement(this.connection.store.value);
+  }
+
+  get resolveDatabasePackageAndName(): [string, string] {
+    if (!this.isCreatingNewDatabase) {
+      return [
+        guaranteeNonNullable(this.database.package).path,
+        this.database.name,
+      ];
+    }
+    assertNonEmptyString(this.targetDatabasePath, 'Must specify database path');
+    assertTrue(
+      isValidFullPath(this.targetDatabasePath),
+      'Invalid database path',
+    );
+    return resolvePackagePathAndElementName(
+      this.targetDatabasePath,
+      this.targetDatabasePath,
+    );
+  }
+
+  setTargetDatabasePath(val: string): void {
+    this.targetDatabasePath = val;
   }
 
   setTreeData(builderTreeData?: DatabaseExplorerTreeData): void {
@@ -208,9 +255,10 @@ export class DatabaseSchemaExplorerState {
     try {
       this.isGeneratingDatabase = true;
       const databaseBuilderInput = new DatabaseBuilderInput(this.connection);
+      const [packagePath, name] = this.resolveDatabasePackageAndName;
       databaseBuilderInput.targetDatabase = new TargetDatabase(
-        guaranteeNonNullable(this.database.package).path,
-        this.database.name,
+        packagePath,
+        name,
       );
       databaseBuilderInput.config.maxTables = undefined;
       databaseBuilderInput.config.enrichTables = false;
@@ -266,9 +314,10 @@ export class DatabaseSchemaExplorerState {
 
       const schema = schemaNode.schema;
       const databaseBuilderInput = new DatabaseBuilderInput(this.connection);
+      const [packagePath, name] = this.resolveDatabasePackageAndName;
       databaseBuilderInput.targetDatabase = new TargetDatabase(
-        guaranteeNonNullable(this.database.package).path,
-        this.database.name,
+        packagePath,
+        name,
       );
       databaseBuilderInput.config.maxTables = undefined;
       databaseBuilderInput.config.enrichTables = true;
@@ -328,9 +377,7 @@ export class DatabaseSchemaExplorerState {
       this.isGeneratingDatabase = true;
 
       const databaseBuilderInput = new DatabaseBuilderInput(this.connection);
-      const [packagePath, name] = resolvePackagePathAndElementName(
-        this.database.path,
-      );
+      const [packagePath, name] = this.resolveDatabasePackageAndName;
       databaseBuilderInput.targetDatabase = new TargetDatabase(
         packagePath,
         name,
@@ -414,9 +461,10 @@ export class DatabaseSchemaExplorerState {
 
       const treeData = guaranteeNonNullable(this.treeData);
       const databaseBuilderInput = new DatabaseBuilderInput(this.connection);
+      const [packagePath, name] = this.resolveDatabasePackageAndName;
       databaseBuilderInput.targetDatabase = new TargetDatabase(
-        guaranteeNonNullable(this.database.package).path,
-        this.database.name,
+        packagePath,
+        name,
       );
       const config = databaseBuilderInput.config;
       config.maxTables = undefined;
@@ -472,7 +520,11 @@ export class DatabaseSchemaExplorerState {
 
     try {
       this.isUpdatingDatabase = true;
-
+      const createDatabase =
+        this.isCreatingNewDatabase &&
+        !this.editorStore.graphManagerState.graph.databases.includes(
+          this.database,
+        );
       const graph = this.editorStore.graphManagerState.createNewGraph();
       (yield this.editorStore.graphManagerState.graphManager.buildGraph(
         graph,
@@ -516,7 +568,23 @@ export class DatabaseSchemaExplorerState {
           this.database.schemas.push(schema);
         }
       });
-
+      if (createDatabase) {
+        connection_setStore(
+          this.connection,
+          PackageableElementExplicitReference.create(database),
+        );
+        const packagePath = guaranteeNonNullable(
+          database.package?.name,
+          'Database package is missing',
+        );
+        yield flowResult(
+          this.editorStore.graphEditorMode.addElement(
+            database,
+            packagePath,
+            false,
+          ),
+        );
+      }
       this.editorStore.applicationStore.notificationService.notifySuccess(
         `Database successfully updated`,
       );

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

@@ -23,8 +23,8 @@ import {
 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 } from '@finos/legend-graph';
 import { DatabaseSchemaExplorerState } from './DatabaseBuilderState.js';
+import type { RelationalDatabaseConnection } from '@finos/legend-graph';
 
 export class DatabaseBuilderWizardState {
   readonly editorStore: EditorStore;
@@ -70,7 +70,6 @@ export class DatabaseBuilderWizardState {
     if (!this.schemaExplorerState.treeData) {
       return;
     }
-
     try {
       this.setDatabaseGrammarCode(
         (yield this.editorStore.graphManagerState.graphManager.entitiesToPureCode(

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

@@ -0,0 +1,156 @@
+/**
+ * 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 { Entity } from '@finos/legend-storage';
+import {
+  type GeneratorFn,
+  assertErrorThrown,
+  LogEvent,
+  guaranteeNonNullable,
+  ActionState,
+} 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 { Database } from '@finos/legend-graph';
+import { EntityChangeType, type EntityChange } from '@finos/legend-server-sdlc';
+
+export class DatabaseModelBuilderState {
+  readonly editorStore: EditorStore;
+  readonly database: Database;
+  readonly isReadOnly: boolean;
+  generatingModelState = ActionState.create();
+  saveModelState = ActionState.create();
+
+  showModal = false;
+  generatedGrammarCode = '';
+  entities: Entity[] | undefined;
+
+  constructor(
+    editorStore: EditorStore,
+    database: Database,
+    isReadOnly: boolean,
+  ) {
+    makeObservable(this, {
+      showModal: observable,
+      generatedGrammarCode: observable,
+      generatingModelState: observable,
+      saveModelState: observable,
+      close: action,
+      setShowModal: action,
+      setEntities: action,
+      setDatabaseGrammarCode: action,
+      saveModels: flow,
+      previewDatabaseModels: flow,
+    });
+    this.editorStore = editorStore;
+    this.database = database;
+    this.isReadOnly = isReadOnly;
+  }
+
+  setShowModal(val: boolean): void {
+    this.showModal = val;
+  }
+
+  setDatabaseGrammarCode(val: string): void {
+    this.generatedGrammarCode = val;
+  }
+
+  setEntities(val: Entity[] | undefined): void {
+    this.entities = val;
+  }
+
+  close(): void {
+    this.setShowModal(false);
+    this.editorStore.explorerTreeState.setDatabaseModelBuilderState(undefined);
+  }
+
+  *previewDatabaseModels(): GeneratorFn<void> {
+    try {
+      this.generatingModelState.isInProgress;
+      this.entities = [];
+      this.setDatabaseGrammarCode('');
+      const entities =
+        (yield this.editorStore.graphManagerState.graphManager.generateModelsFromDatabaseSpecification(
+          this.database.path,
+          this.editorStore.graphManagerState.graph,
+        )) as Entity[];
+
+      this.setEntities(entities);
+      this.setDatabaseGrammarCode(
+        (yield this.editorStore.graphManagerState.graphManager.entitiesToPureCode(
+          entities,
+        )) as string,
+      );
+    } 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);
+    } finally {
+      this.generatingModelState.complete();
+    }
+  }
+
+  *saveModels(): GeneratorFn<void> {
+    try {
+      this.saveModelState.inProgress();
+      const entities = guaranteeNonNullable(this.entities);
+      const newEntities: EntityChange[] = [];
+      for (const entity of entities) {
+        let entityChangeType: EntityChangeType;
+        if (
+          this.editorStore.graphManagerState.graph.getNullableElement(
+            entity.path,
+          ) === undefined
+        ) {
+          entityChangeType = EntityChangeType.CREATE;
+        } else {
+          entityChangeType = EntityChangeType.MODIFY;
+        }
+        newEntities.push({
+          type: entityChangeType,
+          entityPath: entity.path,
+          content: entity.content,
+        });
+      }
+      this.editorStore.explorerTreeState.setDatabaseModelBuilderState(
+        undefined,
+      );
+      this.setShowModal(false);
+      yield flowResult(
+        this.editorStore.graphState.loadEntityChangesToGraph(
+          newEntities,
+          undefined,
+        ),
+      );
+      this.editorStore.applicationStore.notificationService.notifySuccess(
+        'Generated models successfully!',
+      );
+    } 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);
+    } finally {
+      this.saveModelState.complete();
+    }
+  }
+}

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

@@ -622,12 +622,12 @@ export class MappingEditorState extends ElementEditorState {
   mappingExplorerTreeData: TreeData<MappingExplorerTreeNodeData>;
   newMappingElementSpec?: MappingElementSpec | undefined;
 
+  mappingTestableState: MappingTestableState;
+
   // DEPREACTED legacy tests: TO REMOVE once mapping testable dev work is complete
-  mappingTestStates: DEPRECATED__MappingTestState[] = [];
+  DEPRECATED_mappingTestStates: DEPRECATED__MappingTestState[] = [];
   isRunningAllTests = false;
   allTestRunTime = 0;
-  //
-  mappingTestableState: MappingTestableState;
 
   constructor(editorStore: EditorStore, element: PackageableElement) {
     super(editorStore, element);
@@ -635,7 +635,7 @@ export class MappingEditorState extends ElementEditorState {
     makeObservable<MappingEditorState, 'closeMappingElementTabState'>(this, {
       currentTabState: observable,
       openedTabStates: observable,
-      mappingTestStates: observable,
+      DEPRECATED_mappingTestStates: observable,
       newMappingElementSpec: observable,
       isRunningAllTests: observable,
       allTestRunTime: observable,
@@ -666,7 +666,7 @@ export class MappingEditorState extends ElementEditorState {
       deleteMappingElement: flow,
     });
 
-    this.mappingTestStates = this.mapping.test.map(
+    this.DEPRECATED_mappingTestStates = this.mapping.test.map(
       (t) => new DEPRECATED__MappingTestState(editorStore, t, this),
     );
     this.mappingExplorerTreeData = getMappingElementTreeData(
@@ -1238,7 +1238,7 @@ export class MappingEditorState extends ElementEditorState {
           );
           return this.createMappingElementState(mappingElement);
         } else if (tabState instanceof DEPRECATED__MappingTestState) {
-          return mappingEditorState.mappingTestStates.find(
+          return mappingEditorState.DEPRECATED_mappingTestStates.find(
             (testState) => testState.test.name === tabState.test.name,
           );
         } else if (tabState instanceof MappingExecutionState) {
@@ -1264,7 +1264,7 @@ export class MappingEditorState extends ElementEditorState {
       );
     } else if (this.currentTabState instanceof DEPRECATED__MappingTestState) {
       const currentlyOpenedMappingTest =
-        mappingEditorState.mappingTestStates.find(
+        mappingEditorState.DEPRECATED_mappingTestStates.find(
           (testState) =>
             this.currentTabState instanceof DEPRECATED__MappingTestState &&
             testState.test.name === this.currentTabState.test.name,
@@ -1407,7 +1407,7 @@ export class MappingEditorState extends ElementEditorState {
           tabState.test === test,
       ),
     );
-    const testState = this.mappingTestStates.find(
+    const testState = this.DEPRECATED_mappingTestStates.find(
       (mappingTestState) => mappingTestState.test === test,
     );
     assertNonNullable(
@@ -1442,10 +1442,10 @@ export class MappingEditorState extends ElementEditorState {
   }
 
   get testSuiteResult(): TEST_RESULT {
-    const numberOfTestPassed = this.mappingTestStates.filter(
+    const numberOfTestPassed = this.DEPRECATED_mappingTestStates.filter(
       (testState) => testState.result === TEST_RESULT.PASSED,
     ).length;
-    const numberOfTestFailed = this.mappingTestStates.filter(
+    const numberOfTestFailed = this.DEPRECATED_mappingTestStates.filter(
       (testState) =>
         testState.result === TEST_RESULT.FAILED ||
         testState.result === TEST_RESULT.ERROR,
@@ -1461,11 +1461,11 @@ export class MappingEditorState extends ElementEditorState {
     try {
       const startTime = Date.now();
       this.isRunningAllTests = true;
-      this.mappingTestStates.forEach((testState) =>
+      this.DEPRECATED_mappingTestStates.forEach((testState) =>
         testState.resetTestRunStatus(),
       );
-      const input = this.mappingTestStates
-        .map((testState: DEPRECATED__MappingTestState) => {
+      const input = this.DEPRECATED_mappingTestStates.map(
+        (testState: DEPRECATED__MappingTestState) => {
           // run non-skip tests, and reset all skipped tests
           if (!testState.isSkipped) {
             testState.setIsRunningTest(true);
@@ -1480,8 +1480,8 @@ export class MappingEditorState extends ElementEditorState {
           }
           testState.resetTestRunStatus();
           return undefined;
-        })
-        .filter(isNonNullable);
+        },
+      ).filter(isNonNullable);
       yield this.editorStore.graphManagerState.graphManager.DEPRECATED__runLegacyMappingTests(
         input,
         this.mapping,
@@ -1505,7 +1505,7 @@ export class MappingEditorState extends ElementEditorState {
   }
 
   *addTest(test: DEPRECATED__MappingTest): GeneratorFn<void> {
-    this.mappingTestStates.push(
+    this.DEPRECATED_mappingTestStates.push(
       new DEPRECATED__MappingTestState(this.editorStore, test, this),
     );
     mapping_addDEPRECATEDTest(
@@ -1529,9 +1529,10 @@ export class MappingEditorState extends ElementEditorState {
     this.openedTabStates = this.openedTabStates.filter(
       (tabState) => !matchMappingTestState(tabState),
     );
-    this.mappingTestStates = this.mappingTestStates.filter(
-      (tabState) => !matchMappingTestState(tabState),
-    );
+    this.DEPRECATED_mappingTestStates =
+      this.DEPRECATED_mappingTestStates.filter(
+        (tabState) => !matchMappingTestState(tabState),
+      );
   }
 
   *createNewTest(setImplementation: SetImplementation): GeneratorFn<void> {
@@ -1588,7 +1589,7 @@ export class MappingEditorState extends ElementEditorState {
       this.editorStore.changeDetectionState.observerContext,
     );
     // open the test
-    this.mappingTestStates.push(
+    this.DEPRECATED_mappingTestStates.push(
       new DEPRECATED__MappingTestState(this.editorStore, newTest, this),
     );
     yield flowResult(this.openTest(newTest));

package/src/stores/editor/editor-state/element-editor-state/mapping/testable/MappingTestableState.ts

@@ -646,10 +646,12 @@ export class MappingTestableState {
   }
 
   init(): void {
-    const suite = this.mapping.tests[0];
-    this.selectedTestSuite = suite
-      ? this.buildTestSuiteState(suite)
-      : undefined;
+    if (!this.selectedTestSuite) {
+      const suite = this.mapping.tests[0];
+      this.selectedTestSuite = suite
+        ? this.buildTestSuiteState(suite)
+        : undefined;
+    }
   }
 
   openCreateModal(): void {

package/tsconfig.json

@@ -97,6 +97,7 @@
     "./src/stores/editor/editor-state/element-editor-state/connection/ConnectionEditorState.ts",
     "./src/stores/editor/editor-state/element-editor-state/connection/DatabaseBuilderState.ts",
     "./src/stores/editor/editor-state/element-editor-state/connection/DatabaseBuilderWizardState.ts",
+    "./src/stores/editor/editor-state/element-editor-state/connection/DatabaseModelBuilderState.ts",
     "./src/stores/editor/editor-state/element-editor-state/connection/PostProcessorEditorState.ts",
     "./src/stores/editor/editor-state/element-editor-state/data/DataEditorState.ts",
     "./src/stores/editor/editor-state/element-editor-state/data/EmbeddedDataState.ts",
@@ -197,6 +198,7 @@
     "./src/components/editor/editor-group/connection-editor/ConnectionEditor.tsx",
     "./src/components/editor/editor-group/connection-editor/DatabaseBuilderWizard.tsx",
     "./src/components/editor/editor-group/connection-editor/DatabaseEditorHelper.tsx",
+    "./src/components/editor/editor-group/connection-editor/DatabaseModelBuilder.tsx",
     "./src/components/editor/editor-group/connection-editor/DatabaseSchemaExplorer.tsx",
     "./src/components/editor/editor-group/connection-editor/FlatDataConnectionEditor.tsx",
     "./src/components/editor/editor-group/connection-editor/RelationalDatabaseConnectionEditor.tsx",