@finos/legend-application-studio 28.9.0 → 28.10.0

package/src/stores/editor/EditorStore.ts

@@ -108,6 +108,8 @@ import { GraphEditGrammarModeState } from './GraphEditGrammarModeState.js';
 import { GlobalBulkServiceRegistrationState } from './sidebar-state/BulkServiceRegistrationState.js';
 import { SQLPlaygroundPanelState } from './panel-group/SQLPlaygroundPanelState.js';
 import type { QuickInputState } from './QuickInputState.js';
+import { GlobalEndToEndWorkflowState } from './sidebar-state/end-to-end-workflow/GlobalEndToEndFlowState.js';
+import { openShowcaseManager } from '../ShowcaseManagerState.js';
 
 export abstract class EditorExtensionState {
   /**
@@ -162,6 +164,7 @@ export class EditorStore implements CommandRegistrar {
   localChangesState: LocalChangesState;
   conflictResolutionState: WorkspaceUpdateConflictResolutionState;
   globalBulkServiceRegistrationState: GlobalBulkServiceRegistrationState;
+  globalEndToEndWorkflowState: GlobalEndToEndWorkflowState;
   devToolState: DevToolPanelState;
   sqlPlaygroundState: SQLPlaygroundPanelState;
 
@@ -257,6 +260,7 @@ export class EditorStore implements CommandRegistrar {
       this,
       this.sdlcState,
     );
+    this.globalEndToEndWorkflowState = new GlobalEndToEndWorkflowState(this);
     this.workspaceWorkflowManagerState = new WorkspaceWorkflowManagerState(
       this,
       this.sdlcState,
@@ -413,6 +417,18 @@ export class EditorStore implements CommandRegistrar {
         );
       },
     });
+    this.applicationStore.commandService.registerCommand({
+      key: LEGEND_STUDIO_COMMAND_KEY.OPEN_SHOWCASES,
+      trigger: this.createEditorCommandTrigger(
+        () =>
+          this.isInitialized &&
+          (!this.isInConflictResolutionMode ||
+            this.conflictResolutionState.hasResolvedAllConflicts),
+      ),
+      action: () => {
+        openShowcaseManager(this.applicationStore);
+      },
+    });
     this.applicationStore.commandService.registerCommand({
       key: LEGEND_STUDIO_COMMAND_KEY.TOGGLE_MODEL_LOADER,
       trigger: this.createEditorCommandTrigger(() => !this.isInViewerMode),

package/src/stores/editor/ExplorerTreeState.ts

@@ -203,6 +203,7 @@ export class ExplorerTreeState {
       this.editorStore,
       val,
       isReadOnly,
+      this.editorStore.graphManagerState.graph,
     );
     dbBuilderState.setShowModal(true);
     this.setDatabaseModelBuilderState(dbBuilderState);

package/src/stores/editor/GraphEditGrammarModeState.ts

@@ -20,13 +20,13 @@ import {
 } from '@finos/legend-application';
 import {
   type PackageableElement,
-  GRAPH_MANAGER_EVENT,
+  type SourceInformation,
   type TextCompilationResult,
+  type GraphManagerOperationReport,
+  GRAPH_MANAGER_EVENT,
   EngineError,
   GraphBuilderError,
-  type GraphManagerOperationReport,
   reportGraphAnalytics,
-  type SourceInformation,
 } from '@finos/legend-graph';
 import {
   type GeneratorFn,

package/src/stores/editor/NewElementState.ts

@@ -317,7 +317,7 @@ export class NewFlatDataConnectionDriver extends NewConnectionValueDriver<FlatDa
   }
 }
 
-const DEFAULT_H2_SQL =
+export 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) {

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

@@ -72,6 +72,9 @@ import {
   EngineRuntime,
   StoreConnections,
   IdentifiedConnection,
+  getOrCreateGraphPackage,
+  extractElementNameFromPath,
+  extractPackagePathFromPath,
 } from '@finos/legend-graph';
 import { GraphEditFormModeState } from '../../../GraphEditFormModeState.js';
 import { connection_setStore } from '../../../../graph-modifier/DSL_Mapping_GraphModifierHelper.js';
@@ -301,13 +304,14 @@ export interface DatabaseExplorerTreeData
   database: Database;
 }
 
-const DEFAULT_DATABASE_PATH = 'store::MyDatabase';
+export const DEFAULT_DATABASE_PATH = 'store::MyDatabase';
 
 export class DatabaseSchemaExplorerState {
   readonly editorStore: EditorStore;
   readonly connection: RelationalDatabaseConnection;
-  readonly database: Database;
+  database: Database;
   targetDatabasePath: string;
+  makeTargetDatabasePathEditable?: boolean;
 
   isGeneratingDatabase = false;
   isUpdatingDatabase = false;
@@ -322,20 +326,24 @@ export class DatabaseSchemaExplorerState {
     makeObservable(this, {
       isGeneratingDatabase: observable,
       isUpdatingDatabase: observable,
+      database: observable,
       treeData: observable,
       targetDatabasePath: observable,
       previewer: observable,
       previewDataState: observable,
+      makeTargetDatabasePathEditable: observable,
       isCreatingNewDatabase: computed,
       resolveDatabasePackageAndName: computed,
       setTreeData: action,
       setTargetDatabasePath: action,
+      setMakeTargetDatabasePathEditable: action,
       onNodeSelect: flow,
       fetchDatabaseMetadata: flow,
       fetchSchemaMetadata: flow,
       fetchTableMetadata: flow,
       generateDatabase: flow,
       updateDatabase: flow,
+      updateDatabaseAndGraph: flow,
       previewData: flow,
     });
 
@@ -349,8 +357,12 @@ export class DatabaseSchemaExplorerState {
     return isStubbed_PackageableElement(this.connection.store.value);
   }
 
+  setMakeTargetDatabasePathEditable(val: boolean): void {
+    this.makeTargetDatabasePathEditable = val;
+  }
+
   get resolveDatabasePackageAndName(): [string, string] {
-    if (!this.isCreatingNewDatabase) {
+    if (!this.isCreatingNewDatabase && !this.makeTargetDatabasePathEditable) {
       return [
         guaranteeNonNullable(this.database.package).path,
         this.database.name,
@@ -799,61 +811,77 @@ export class DatabaseSchemaExplorerState {
     }
   }
 
-  *updateDatabase(): GeneratorFn<void> {
+  // this method just updates database
+  *updateDatabase(): GeneratorFn<Database> {
+    this.isUpdatingDatabase = true;
+    const graph = this.editorStore.graphManagerState.createNewGraph();
+    (yield this.editorStore.graphManagerState.graphManager.buildGraph(
+      graph,
+      [(yield flowResult(this.generateDatabase())) as Entity],
+      ActionState.create(),
+    )) as Entity[];
+    const database = getNonNullableEntry(
+      graph.ownDatabases,
+      0,
+      'Expected one database to be generated from input',
+    );
+    // remove undefined schemas
+    const schemas = Array.from(
+      guaranteeNonNullable(this.treeData).nodes.values(),
+    )
+      .map((schemaNode) => {
+        if (schemaNode instanceof DatabaseSchemaExplorerTreeSchemaNodeData) {
+          return schemaNode.schema;
+        }
+        return undefined;
+      })
+      .filter(isNonNullable);
+
+    // update this.database packge and name
+    this.database.package = getOrCreateGraphPackage(
+      graph,
+      extractPackagePathFromPath(this.targetDatabasePath),
+      undefined,
+    );
+    this.database.name = extractElementNameFromPath(this.targetDatabasePath);
+    this.database.schemas = this.database.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 = this.database;
+      const currentSchemaIndex = this.database.schemas.findIndex(
+        (item) => item.name === schema.name,
+      );
+      if (currentSchemaIndex !== -1) {
+        this.database.schemas[currentSchemaIndex] = schema;
+      } else {
+        this.database.schemas.push(schema);
+      }
+    });
+    this.isUpdatingDatabase = false;
+    return database;
+  }
+
+  // this method updates database and add database to the graph
+  *updateDatabaseAndGraph(): GeneratorFn<void> {
     if (!this.treeData) {
       return;
     }
-
     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,
-        [(yield flowResult(this.generateDatabase())) as Entity],
-        ActionState.create(),
-      )) as Entity[];
-      const database = getNonNullableEntry(
-        graph.ownDatabases,
-        0,
-        'Expected one database to be generated from input',
-      );
-
-      // remove undefined schemas
-      const schemas = Array.from(this.treeData.nodes.values())
-        .map((schemaNode) => {
-          if (schemaNode instanceof DatabaseSchemaExplorerTreeSchemaNodeData) {
-            return schemaNode.schema;
-          }
-          return undefined;
-        })
-        .filter(isNonNullable);
-      this.database.schemas = this.database.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 = this.database;
-        const currentSchemaIndex = this.database.schemas.findIndex(
-          (item) => item.name === schema.name,
-        );
-        if (currentSchemaIndex !== -1) {
-          this.database.schemas[currentSchemaIndex] = schema;
-        } else {
-          this.database.schemas.push(schema);
-        }
-      });
+      this.isUpdatingDatabase = true;
+      const database = (yield flowResult(this.updateDatabase())) as Database;
       if (createDatabase) {
         connection_setStore(
           this.connection,

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

@@ -95,8 +95,7 @@ export class DatabaseBuilderWizardState {
     if (!this.schemaExplorerState.treeData) {
       return;
     }
-
-    yield flowResult(this.schemaExplorerState.updateDatabase());
+    yield flowResult(this.schemaExplorerState.updateDatabaseAndGraph());
     this.setShowModal(false);
   }
 }

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

@@ -25,7 +25,11 @@ 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 Database, DEFAULT_GENERATION_PACKAGE } from '@finos/legend-graph';
+import {
+  type Database,
+  type PureModel,
+  DEFAULT_GENERATION_PACKAGE,
+} from '@finos/legend-graph';
 import { EntityChangeType, type EntityChange } from '@finos/legend-server-sdlc';
 
 export class DatabaseModelBuilderState {
@@ -39,16 +43,19 @@ export class DatabaseModelBuilderState {
   generatedGrammarCode = '';
   entities: Entity[] | undefined;
   targetPackage: string;
+  graph: PureModel;
 
   constructor(
     editorStore: EditorStore,
     database: Database,
     isReadOnly: boolean,
+    graph: PureModel,
   ) {
     makeObservable(this, {
       showModal: observable,
       generatedGrammarCode: observable,
       generatingModelState: observable,
+      graph: observable,
       saveModelState: observable,
       targetPackage: observable,
       close: action,
@@ -63,6 +70,7 @@ export class DatabaseModelBuilderState {
     this.database = database;
     this.isReadOnly = isReadOnly;
     this.targetPackage = database.package?.path ?? DEFAULT_GENERATION_PACKAGE;
+    this.graph = graph;
   }
 
   setShowModal(val: boolean): void {
@@ -88,13 +96,13 @@ export class DatabaseModelBuilderState {
 
   *previewDatabaseModels(): GeneratorFn<void> {
     try {
-      this.generatingModelState.isInProgress;
+      this.generatingModelState.inProgress();
       this.entities = [];
       const entities =
         (yield this.editorStore.graphManagerState.graphManager.generateModelsFromDatabaseSpecification(
           this.database.path,
           this.targetPackage,
-          this.editorStore.graphManagerState.graph,
+          this.graph,
         )) as Entity[];
       this.setEntities(entities);
       this.setDatabaseGrammarCode(
@@ -122,11 +130,7 @@ export class DatabaseModelBuilderState {
       const newEntities: EntityChange[] = [];
       for (const entity of entities) {
         let entityChangeType: EntityChangeType;
-        if (
-          this.editorStore.graphManagerState.graph.getNullableElement(
-            entity.path,
-          ) === undefined
-        ) {
+        if (this.graph.getNullableElement(entity.path) === undefined) {
           entityChangeType = EntityChangeType.CREATE;
         } else {
           entityChangeType = EntityChangeType.MODIFY;

package/src/stores/editor/editor-state/end-to-end-workflow-state/EndToEndWorkflowEditorState.ts

@@ -0,0 +1,25 @@
+/**
+ * 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 { EditorState } from '../../editor-state/EditorState.js';
+import { SupportedEndToEndWorkflow } from '../../sidebar-state/end-to-end-workflow/GlobalEndToEndFlowState.js';
+
+export abstract class EndToEndWorkflowEditorState extends EditorState {}
+export class QueryConnectionEndToEndWorkflowEditorState extends EndToEndWorkflowEditorState {
+  override get label(): string {
+    return SupportedEndToEndWorkflow.CREATE_QUERY_FROM_CONNECTION;
+  }
+}