@finos/legend-application-studio 27.0.0 → 27.1.1

package/src/stores/editor/NewElementState.ts

@@ -74,6 +74,12 @@ import {
   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 {
@@ -613,7 +619,6 @@ export class NewDataElementDriver extends NewElementDriver<DataElement> {
   createElement(name: string): DataElement {
     const embeddedDataOption = guaranteeNonNullable(this.embeddedDataOption);
     const dataElement = new DataElement(name);
-
     const data = createEmbeddedData(embeddedDataOption.value, this.editorStore);
     dataElement_setEmbeddedData(
       dataElement,
@@ -646,7 +651,6 @@ export class NewElementState {
       _package: observable,
       name: observable,
       newElementDriver: observable,
-      elementAndPackageName: computed,
       selectedPackage: computed,
       isValid: computed,
       setShowModal: action,
@@ -665,14 +669,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
@@ -778,7 +774,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,
@@ -789,17 +789,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/data/DataEditorState.ts

@@ -26,6 +26,7 @@ import { ElementEditorState } from '../ElementEditorState.js';
 import {
   type EmbeddedDataState,
   buildEmbeddedDataEditorState,
+  type EmbeddedDataStateOption,
 } from './EmbeddedDataState.js';
 
 export enum DATA_TAB_TYPE {
@@ -45,12 +46,17 @@ export class EmbeddedDataEditorState {
   readonly embeddedData: EmbeddedData;
   readonly embeddedDataState: EmbeddedDataState;
 
-  constructor(editorStore: EditorStore, embeddedData: EmbeddedData) {
+  constructor(
+    editorStore: EditorStore,
+    embeddedData: EmbeddedData,
+    options?: EmbeddedDataStateOption,
+  ) {
     this.editorStore = editorStore;
     this.embeddedData = embeddedData;
     this.embeddedDataState = buildEmbeddedDataEditorState(
       embeddedData,
       editorStore,
+      options,
     );
   }
 }

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

@@ -17,11 +17,12 @@ import {
   type EmbeddedData,
   type ModelData,
   type DataElement,
+  RelationalCSVData,
+  type Database,
+  type RelationalCSVDataTable,
   DataElementReference,
   ExternalFormatData,
   ModelStoreData,
-  RelationalCSVData,
-  RelationalCSVDataTable,
   ModelEmbeddedData,
 } from '@finos/legend-graph';
 import {
@@ -40,8 +41,6 @@ import {
   externalFormatData_setData,
   relationalData_addTable,
   relationalData_deleteData,
-  relationalData_setTableName,
-  relationalData_setTableSchemaName,
   relationalData_setTableValues,
 } from '../../../../graph-modifier/DSL_Data_GraphModifierHelper.js';
 import { EmbeddedDataType } from '../../ExternalFormatState.js';
@@ -168,15 +167,26 @@ export class UnsupportedModelDataState extends ModelDataState {}
 export class ModelStoreDataState extends EmbeddedDataState {
   override embeddedData: ModelStoreData;
   modelDataStates: ModelDataState[] = [];
+  hideClass = false;
 
-  constructor(editorStore: EditorStore, embeddedData: ModelStoreData) {
+  constructor(
+    editorStore: EditorStore,
+    embeddedData: ModelStoreData,
+    hideClass?: boolean,
+  ) {
     super(editorStore, embeddedData);
+    makeObservable(this, {
+      hideClass: observable,
+      modelDataStates: observable,
+      buildStates: action,
+    });
     this.embeddedData = embeddedData;
     this.modelDataStates = this.buildStates();
+    this.hideClass = Boolean(hideClass);
   }
 
   label(): string {
-    return 'ModelStore Data';
+    return 'Model Store Data';
   }
 
   buildStates(): ModelDataState[] {
@@ -209,72 +219,15 @@ export class RelationalCSVDataTableState {
   }
 }
 
-export class IdentifierTableState {
-  table: RelationalCSVDataTable | undefined;
-  dataState: RelationalCSVDataState;
-  schemaName = '';
-  tableName = '';
-
-  constructor(dataState: RelationalCSVDataState) {
-    this.dataState = dataState;
-    makeObservable(this, {
-      dataState: observable,
-      schemaName: observable,
-      tableName: observable,
-      table: observable,
-      setTableName: action,
-      setSchemaName: action,
-      setTable: action,
-      handleSubmit: action,
-    });
-  }
-
-  setTable(table: RelationalCSVDataTable | undefined): void {
-    this.table = table;
-    if (table) {
-      this.tableName = table.table;
-      this.schemaName = table.schema;
-    }
-  }
-
-  setTableName(val: string): void {
-    this.tableName = val;
-  }
-
-  setSchemaName(val: string): void {
-    this.schemaName = val;
-  }
-
-  get isEditingDisabled(): boolean {
-    if (!(this.tableName && this.schemaName)) {
-      return true;
-    }
-    return Boolean(
-      this.dataState.embeddedData.tables.find(
-        (t) =>
-          `${t.table}.${t.schema}` === `${this.tableName}.${this.schemaName}`,
-      ),
-    );
-  }
-
-  handleSubmit(): void {
-    const table = this.table ?? new RelationalCSVDataTable();
-    relationalData_setTableSchemaName(table, this.schemaName);
-    relationalData_setTableName(table, this.tableName);
-    if (!this.table) {
-      table.values = '';
-      relationalData_addTable(this.dataState.embeddedData, table);
-      this.dataState.changeSelectedTable(table);
-    }
-  }
-}
-
 export class RelationalCSVDataState extends EmbeddedDataState {
   override embeddedData: RelationalCSVData;
-  showTableIdentifierModal = false;
-  tableIdentifierState: IdentifierTableState;
   selectedTable: RelationalCSVDataTableState | undefined;
   showImportCSVModal = false;
+  database: Database | undefined;
+
+  //
+  showTableIdentifierModal = false;
+  tableToEdit: RelationalCSVDataTable | undefined;
 
   constructor(editorStore: EditorStore, embeddedData: RelationalCSVData) {
     super(editorStore, embeddedData);
@@ -282,10 +235,11 @@ export class RelationalCSVDataState extends EmbeddedDataState {
       selectedTable: observable,
       showTableIdentifierModal: observable,
       deleteTable: observable,
-      tableIdentifierState: observable,
       showImportCSVModal: observable,
+      database: observable,
       resetSelectedTable: action,
       changeSelectedTable: action,
+      setDatabase: action,
       closeModal: action,
       openIdentifierModal: action,
       setShowImportCsvModal: action,
@@ -293,7 +247,6 @@ export class RelationalCSVDataState extends EmbeddedDataState {
       importCSV: action,
     });
     this.embeddedData = embeddedData;
-    this.tableIdentifierState = new IdentifierTableState(this);
     this.resetSelectedTable();
   }
 
@@ -301,9 +254,13 @@ export class RelationalCSVDataState extends EmbeddedDataState {
     this.showImportCSVModal = val;
   }
 
+  setDatabase(val: Database | undefined): void {
+    this.database = val;
+  }
+
   openIdentifierModal(renameTable?: RelationalCSVDataTable | undefined): void {
     this.showTableIdentifierModal = true;
-    this.tableIdentifierState.setTable(renameTable);
+    this.tableToEdit = renameTable;
   }
 
   closeCSVModal(): void {
@@ -311,9 +268,8 @@ export class RelationalCSVDataState extends EmbeddedDataState {
   }
 
   closeModal(): void {
-    this.tableIdentifierState.setSchemaName('');
-    this.tableIdentifierState.setTableName('');
     this.showTableIdentifierModal = false;
+    this.tableToEdit = undefined;
   }
 
   importCSV(val: string): void {
@@ -351,14 +307,23 @@ export class RelationalCSVDataState extends EmbeddedDataState {
     return 'Relational Data';
   }
 }
+export interface EmbeddedDataStateOption {
+  hideSource?: boolean;
+}
 
 export class DataElementReferenceState extends EmbeddedDataState {
   override embeddedData: DataElementReference;
   embeddedDataValueState: EmbeddedDataState;
+  options?: EmbeddedDataStateOption | undefined;
 
-  constructor(editorStore: EditorStore, embeddedData: DataElementReference) {
+  constructor(
+    editorStore: EditorStore,
+    embeddedData: DataElementReference,
+    options?: EmbeddedDataStateOption,
+  ) {
     super(editorStore, embeddedData);
     this.embeddedData = embeddedData;
+    this.options = options;
     this.embeddedDataValueState = this.buildValueState();
   }
 
@@ -375,10 +340,11 @@ export class DataElementReferenceState extends EmbeddedDataState {
     this.embeddedDataValueState = this.buildValueState();
   }
 
-  buildValueState(): EmbeddedDataState {
+  buildValueState(options?: EmbeddedDataStateOption): EmbeddedDataState {
     return buildEmbeddedDataEditorState(
       this.embeddedData.dataElement.value.data,
       this.editorStore,
+      this.options,
     );
   }
 }
@@ -392,16 +358,21 @@ export class UnsupportedDataState extends EmbeddedDataState {
 export function buildEmbeddedDataEditorState(
   _embeddedData: EmbeddedData,
   editorStore: EditorStore,
+  options?: EmbeddedDataStateOption,
 ): EmbeddedDataState {
   const embeddedData = _embeddedData;
   if (embeddedData instanceof ExternalFormatData) {
     return new ExternalFormatDataState(editorStore, embeddedData);
   } else if (embeddedData instanceof ModelStoreData) {
-    return new ModelStoreDataState(editorStore, embeddedData);
+    return new ModelStoreDataState(
+      editorStore,
+      embeddedData,
+      options?.hideSource,
+    );
   } else if (embeddedData instanceof RelationalCSVData) {
     return new RelationalCSVDataState(editorStore, embeddedData);
   } else if (embeddedData instanceof DataElementReference) {
-    return new DataElementReferenceState(editorStore, embeddedData);
+    return new DataElementReferenceState(editorStore, embeddedData, options);
   } else {
     const extraEmbeddedDataEditorStateBuilders = editorStore.pluginManager
       .getApplicationPlugins()

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