@finos/legend-application-studio 26.1.11 → 27.1.0

package/src/stores/editor/editor-state/element-editor-state/service/ServicePostValidationState.ts

@@ -411,7 +411,7 @@ export class PostValidationState {
     );
     serviceValidation_deleteAssertion(this.validation, assertion);
     this.assertionStates = this.assertionStates.filter(
-      (e) => !(e === _assertionState),
+      (e) => e !== _assertionState,
     );
   }
 }

package/src/stores/editor/editor-state/element-editor-state/service/testable/ServiceTestEditorState.ts

@@ -254,10 +254,20 @@ export class ServiceTestSetupState {
             ),
             this.editorStore.graphManagerState.graph,
           );
-
         if (valueSpec instanceof LambdaFunctionInstanceValue) {
           return this.getBindingWithParamRecursively(
-            valueSpec.values[0]?.expressionSequence[0],
+            valueSpec.values[0]?.expressionSequence.find(
+              (exp) =>
+                exp instanceof SimpleFunctionExpression &&
+                (matchFunctionName(
+                  exp.functionName,
+                  QUERY_BUILDER_SUPPORTED_FUNCTIONS.SERIALIZE,
+                ) ||
+                  matchFunctionName(
+                    exp.functionName,
+                    QUERY_BUILDER_SUPPORTED_FUNCTIONS.EXTERNALIZE,
+                  )),
+            ),
           );
         }
       } catch (error) {

package/src/stores/editor/editor-state/project-configuration-editor-state/ProjectDependencyEditorState.ts

@@ -316,7 +316,7 @@ export class ProjectDependencyEditorState {
       reportTab: observable,
       expandConflictsState: observable,
       buildConflictPathState: observable,
-      setDependencyReport: action,
+      setReportTab: action,
       expandAllConflicts: action,
       setFlattenDependencyTreeData: action,
       clearTrees: action,
@@ -356,7 +356,7 @@ export class ProjectDependencyEditorState {
     }
   }
 
-  setDependencyReport(tab: DEPENDENCY_REPORT_TAB | undefined): void {
+  setReportTab(tab: DEPENDENCY_REPORT_TAB | undefined): void {
     this.reportTab = tab;
   }
 

package/src/stores/editor/panel-group/SQLPlaygroundPanelState.ts

@@ -25,6 +25,9 @@ import {
   ActionState,
   getNonNullableEntry,
   getNullableLastEntry,
+  type Writable,
+  guaranteeNonNullable,
+  IllegalStateError,
 } from '@finos/legend-shared';
 import { observable, makeObservable, flow, flowResult, action } from 'mobx';
 import { editor as monacoEditorAPI } from 'monaco-editor';
@@ -40,6 +43,8 @@ import {
   getSchema,
   guaranteeRelationalDatabaseConnection,
   GRAPH_MANAGER_EVENT,
+  getNullableSchema,
+  getNullableTable,
 } from '@finos/legend-graph';
 import type { EditorStore } from '../EditorStore.js';
 import { LEGEND_STUDIO_APP_EVENT } from '../../../__lib__/LegendStudioEvent.js';
@@ -50,6 +55,8 @@ import {
 import type { CommandRegistrar } from '@finos/legend-application';
 import { STO_RELATIONAL_LEGEND_STUDIO_COMMAND_KEY } from '../../../__lib__/STO_Relational_LegendStudioCommand.js';
 import { PANEL_MODE } from '../EditorConfig.js';
+import type { Entity } from '@finos/legend-storage';
+import { GraphEditFormModeState } from '../GraphEditFormModeState.js';
 
 export abstract class DatabaseSchemaExplorerTreeNodeData
   implements TreeNodeData
@@ -59,12 +66,22 @@ export abstract class DatabaseSchemaExplorerTreeNodeData
   label: string;
   parentId?: string | undefined;
   childrenIds?: string[] | undefined;
+  isChecked = false;
 
   constructor(id: string, label: string, parentId: string | undefined) {
+    makeObservable(this, {
+      isChecked: observable,
+      setChecked: action,
+    });
+
     this.id = id;
     this.label = label;
     this.parentId = parentId;
   }
+
+  setChecked(val: boolean): void {
+    this.isChecked = val;
+  }
 }
 
 export class DatabaseSchemaExplorerTreeSchemaNodeData extends DatabaseSchemaExplorerTreeNodeData {
@@ -118,6 +135,7 @@ export class SQLPlaygroundPanelState implements CommandRegistrar {
   isExecutingRawSQL = false;
 
   connection?: PackageableConnection | undefined;
+  database?: Database | undefined;
   treeData?: DatabaseSchemaExplorerTreeData | undefined;
   readonly sqlEditorTextModel: monacoEditorAPI.ITextModel;
   sqlEditor?: monacoEditorAPI.IStandaloneCodeEditor | undefined;
@@ -125,17 +143,23 @@ export class SQLPlaygroundPanelState implements CommandRegistrar {
   sqlText = DEFAULT_SQL_TEXT;
   sqlExecutionResult?: string | undefined;
 
+  isBuildingDatabase = false;
+  isUpdatingDatabase = false;
+
   constructor(editorStore: EditorStore) {
     makeObservable(this, {
       isFetchingSchema: observable,
       isExecutingRawSQL: observable,
       connection: observable,
+      database: observable,
       treeData: observable,
       sqlText: observable,
       resetSQL: action,
       sqlExecutionResult: observable,
       sqlEditor: observable.ref,
       sqlEditorViewState: observable.ref,
+      isBuildingDatabase: observable,
+      isUpdatingDatabase: observable,
       setTreeData: action,
       setConnection: action,
       setSQLEditor: action,
@@ -146,6 +170,8 @@ export class SQLPlaygroundPanelState implements CommandRegistrar {
       fetchSchemaMetadata: flow,
       fetchTableMetadata: flow,
       executeRawSQL: flow,
+      generateDatabase: flow,
+      updateDatabase: flow,
     });
 
     this.editorStore = editorStore;
@@ -161,6 +187,9 @@ export class SQLPlaygroundPanelState implements CommandRegistrar {
 
   setConnection(val: PackageableConnection | undefined): void {
     this.connection = val;
+    if (val) {
+      this.database = guaranteeRelationalDatabaseConnection(val).store.value;
+    }
     this.sqlEditorTextModel.setValue(DEFAULT_SQL_TEXT);
   }
 
@@ -238,10 +267,37 @@ export class SQLPlaygroundPanelState implements CommandRegistrar {
     treeData: DatabaseSchemaExplorerTreeData,
   ): DatabaseSchemaExplorerTreeNodeData[] | undefined {
     return node.childrenIds
-      ?.map((n) => treeData.nodes.get(n))
+      ?.map((childNode) => treeData.nodes.get(childNode))
       .filter(isNonNullable);
   }
 
+  toggleCheckedNode(
+    node: DatabaseSchemaExplorerTreeNodeData,
+    treeData: DatabaseSchemaExplorerTreeData,
+  ): void {
+    node.setChecked(!node.isChecked);
+    if (node instanceof DatabaseSchemaExplorerTreeSchemaNodeData) {
+      this.getChildNodes(node, treeData)?.forEach((childNode) => {
+        childNode.setChecked(node.isChecked);
+      });
+    } else if (node instanceof DatabaseSchemaExplorerTreeTableNodeData) {
+      if (node.parentId) {
+        const parent = treeData.nodes.get(node.parentId);
+        if (
+          parent &&
+          this.getChildNodes(parent, treeData)?.every(
+            (e) => e.isChecked === node.isChecked,
+          )
+        ) {
+          parent.setChecked(node.isChecked);
+        }
+      }
+    }
+
+    // TODO: support toggling check for columns
+    this.setTreeData({ ...treeData });
+  }
+
   *fetchDatabaseMetadata(): GeneratorFn<void> {
     if (!this.connection) {
       return;
@@ -279,6 +335,14 @@ export class SQLPlaygroundPanelState implements CommandRegistrar {
             dbSchema,
           );
           nodes.set(schemaId, schemaNode);
+
+          schemaNode.setChecked(
+            Boolean(
+              this.database?.schemas.find(
+                (schema) => schema.name === dbSchema.name,
+              ),
+            ),
+          );
         });
       const treeData = { rootIds, nodes, database };
       this.setTreeData(treeData);
@@ -339,6 +403,22 @@ export class SQLPlaygroundPanelState implements CommandRegistrar {
           );
           treeData.nodes.set(tableId, tableNode);
           addUniqueEntry(childrenIds, tableId);
+
+          if (this.database) {
+            const matchingSchema = getNullableSchema(
+              this.database,
+              schema.name,
+            );
+            tableNode.setChecked(
+              Boolean(
+                matchingSchema
+                  ? getNullableTable(matchingSchema, table.name)
+                  : undefined,
+              ),
+            );
+          } else {
+            tableNode.setChecked(false);
+          }
         });
       schemaNode.childrenIds = childrenIds;
       this.setTreeData({ ...treeData });
@@ -482,4 +562,147 @@ export class SQLPlaygroundPanelState implements CommandRegistrar {
       this.isExecutingRawSQL = false;
     }
   }
+
+  *generateDatabase(): GeneratorFn<Entity> {
+    if (!this.database || !this.connection || !this.treeData) {
+      throw new IllegalStateError(
+        `Can't build database: builder is not properly set up`,
+      );
+    }
+
+    try {
+      this.isBuildingDatabase = true;
+
+      const treeData = this.treeData;
+      const databaseBuilderInput = new DatabaseBuilderInput(
+        guaranteeRelationalDatabaseConnection(this.connection),
+      );
+      const packagePath = guaranteeNonNullable(this.database.package).path;
+      const databaseName = this.database.name;
+      databaseBuilderInput.targetDatabase = new TargetDatabase(
+        packagePath,
+        databaseName,
+      );
+      const config = databaseBuilderInput.config;
+      config.maxTables = undefined;
+      config.enrichTables = true;
+      config.enrichColumns = true;
+      config.enrichPrimaryKeys = true;
+      treeData.rootIds
+        .map((e) => treeData.nodes.get(e))
+        .filter(isNonNullable)
+        .forEach((schemaNode) => {
+          if (schemaNode instanceof DatabaseSchemaExplorerTreeSchemaNodeData) {
+            const tableNodes = this.getChildNodes(schemaNode, treeData);
+            const allChecked = tableNodes?.every((t) => t.isChecked === true);
+            if (
+              allChecked ||
+              (schemaNode.isChecked && !schemaNode.childrenIds)
+            ) {
+              config.patterns.push(
+                new DatabasePattern(schemaNode.schema.name, undefined),
+              );
+            } else {
+              tableNodes?.forEach((t) => {
+                if (
+                  t instanceof DatabaseSchemaExplorerTreeTableNodeData &&
+                  t.isChecked
+                ) {
+                  config.patterns.push(
+                    new DatabasePattern(schemaNode.schema.name, t.table.name),
+                  );
+                }
+              });
+            }
+          }
+        });
+      const entities =
+        (yield this.editorStore.graphManagerState.graphManager.buildDatabase(
+          databaseBuilderInput,
+        )) as Entity[];
+      return getNonNullableEntry(
+        entities,
+        0,
+        'Expected a database to be generated',
+      );
+    } finally {
+      this.isBuildingDatabase = false;
+    }
+  }
+
+  *updateDatabase(): GeneratorFn<void> {
+    if (!this.treeData || !this.database || !this.connection) {
+      return;
+    }
+
+    try {
+      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 generatedDatabase = getNonNullableEntry(
+        graph.ownDatabases,
+        0,
+        'Expected one database to be generated from input',
+      );
+
+      const currentDatabase = this.database;
+
+      // remove undefined schemas
+      const schemas = Array.from(this.treeData.nodes.values())
+        .map((schemaNode) => {
+          if (schemaNode instanceof DatabaseSchemaExplorerTreeSchemaNodeData) {
+            return schemaNode.schema;
+          }
+          return undefined;
+        })
+        .filter(isNonNullable);
+      currentDatabase.schemas = currentDatabase.schemas.filter((schema) => {
+        if (
+          schemas.find((item) => item.name === schema.name) &&
+          !generatedDatabase.schemas.find((s) => s.name === schema.name)
+        ) {
+          return false;
+        }
+        return true;
+      });
+
+      // update existing schemas
+      generatedDatabase.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 updated`,
+      );
+      yield flowResult(
+        this.editorStore
+          .getGraphEditorMode(GraphEditFormModeState)
+          .globalCompile({
+            message: `Can't compile graph after editing database. Redirecting you to text mode`,
+          }),
+      );
+    } 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);
+    } finally {
+      this.isUpdatingDatabase = false;
+    }
+  }
 }

package/src/stores/editor/sidebar-state/BulkServiceRegistrationState.ts

@@ -152,7 +152,7 @@ export class GlobalBulkServiceRegistrationState {
   }
 
   setSelectAll(val: boolean): void {
-    this.bulkServiceRegistrationStates.map(
+    this.bulkServiceRegistrationStates.forEach(
       (serviceRegistrationState) => (serviceRegistrationState.isSelected = val),
     );
   }

package/src/stores/editor/utils/MockDataUtils.ts

@@ -242,7 +242,7 @@ export const getPrimitiveTypeFromRelationalType = (
 export const createMockDataForColumn = (
   col: Column,
   isPrimaryKey: boolean,
-  idx?: number | number,
+  idx?: number | undefined,
 ): string | undefined => {
   const type = col.type;
 

package/src/stores/editor/utils/ModelClassifierUtils.ts

@@ -70,10 +70,6 @@ export enum PACKAGEABLE_ELEMENT_TYPE {
   SECTION_INDEX = 'SECTION_INDEX',
   DATA = 'DATA',
 
-  UNKNOWN = 'UNKNOWN',
-}
-
-export enum BASIC_SET_IMPLEMENTATION_TYPE {
-  OPERATION = 'operation',
-  INSTANCE = 'instance',
+  TEMPORARY__LOCAL_CONNECTION = 'LOCAL_CONNECTION',
+  INTERNAL__UNKNOWN = 'UNKNOWN',
 }

package/src/stores/editor/utils/PackageTreeUtils.ts

@@ -367,7 +367,7 @@ export const openNode = (
   let currentElement: PackageableElement | undefined = element;
   let openingNode: PackageTreeNodeData | undefined;
   while (currentElement.package) {
-    const node: PackageTreeNodeData =
+    const currentNode: PackageTreeNodeData =
       treeData.nodes.get(currentElement.path) ??
       addNode(
         editorStore,
@@ -376,8 +376,8 @@ export const openNode = (
         childFilter,
         isDependencyElement,
       );
-    node.isOpen = currentElement instanceof Package;
-    openingNode = !openingNode ? node : openingNode;
+    currentNode.isOpen = currentElement instanceof Package;
+    openingNode = !openingNode ? currentNode : openingNode;
     currentElement = currentElement.package;
   }
   // Open the dependency root