@finos/legend-application-studio 22.1.4 → 22.1.6

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

@@ -23,9 +23,9 @@ import {
   NewPureModelConnectionDriver,
   NewFileGenerationDriver,
   resolvePackageAndElementName,
-  CONNECTION_TYPE,
   NewDataElementDriver,
   NewServiceDriver,
+  CONNECTION_TYPE,
 } from '../../../stores/editor/NewElementState.js';
 import { Dialog, compareLabelFn, CustomSelectorInput } from '@finos/legend-art';
 import type { EditorStore } from '../../../stores/EditorStore.js';
@@ -50,6 +50,7 @@ import type { EmbeddedDataTypeOption } from '../../../stores/editor-state/elemen
 import type { DSL_Data_LegendStudioApplicationPlugin_Extension } from '../../../stores/DSL_Data_LegendStudioApplicationPlugin_Extension.js';
 import { PACKAGEABLE_ELEMENT_TYPE } from '../../../stores/shared/ModelClassifierUtils.js';
 import { EmbeddedDataType } from '../../../stores/editor-state/ExternalFormatState.js';
+import type { DSL_Mapping_LegendStudioApplicationPlugin_Extension } from '../../../stores/DSL_Mapping_LegendStudioApplicationPlugin_Extension.js';
 
 export const getElementTypeLabel = (
   editorStore: EditorStore,
@@ -194,31 +195,9 @@ const NewRuntimeDriverEditor = observer(() => {
 });
 
 const NewPureModelConnectionDriverEditor = observer(
-  (props: {
-    newConnectionDriver: NewPackageableConnectionDriver;
-    newConnectionValueDriver: NewPureModelConnectionDriver;
-  }) => {
-    const { newConnectionDriver, newConnectionValueDriver } = props;
+  (props: { newConnectionValueDriver: NewPureModelConnectionDriver }) => {
+    const { newConnectionValueDriver } = props;
     const editorStore = useEditorStore();
-    // store
-    const store = newConnectionDriver.store;
-    let storeOptions: { label: string; value?: Store | undefined }[] = [
-      { label: 'ModelStore', value: undefined },
-    ];
-    storeOptions = storeOptions.concat(
-      editorStore.graphManagerState.usableStores
-        .map(buildElementOption)
-        .slice()
-        .sort(compareLabelFn),
-    );
-    const selectedStoreOption = {
-      label: store?.path ?? 'ModelStore',
-      value: store,
-    };
-    const onStoreSelectionChange = (val: {
-      label: string;
-      value?: Store;
-    }): void => newConnectionDriver.setStore(val.value);
     // class
     const _class = newConnectionValueDriver.class;
     const classOptions = editorStore.graphManagerState.usableClasses
@@ -242,18 +221,6 @@ const NewPureModelConnectionDriverEditor = observer(
     }
     return (
       <>
-        <div className="panel__content__form__section__header__label">
-          Source Store
-        </div>
-        <div className="explorer__new-element-modal__driver">
-          <CustomSelectorInput
-            className="explorer__new-element-modal__driver__dropdown"
-            options={storeOptions}
-            onChange={onStoreSelectionChange}
-            value={selectedStoreOption}
-            darkMode={true}
-          />
-        </div>
         <div className="panel__content__form__section__header__label">
           Source Class
         </div>
@@ -283,7 +250,6 @@ const NewConnectionValueDriverEditor = observer(() => {
   if (newConnectionValueDriver instanceof NewPureModelConnectionDriver) {
     return (
       <NewPureModelConnectionDriverEditor
-        newConnectionDriver={newConnectionDriver}
         newConnectionValueDriver={newConnectionValueDriver}
       />
     );
@@ -302,17 +268,46 @@ const NewConnectionDriverEditor = observer(() => {
     label: prettyCONSTName(currentConnectionType),
     value: currentConnectionType,
   };
-  const connectionOptions = Object.values(CONNECTION_TYPE).map((e) => ({
-    label: prettyCONSTName(e),
-    value: e,
-  }));
+  const extraOptionTypes = editorStore.pluginManager
+    .getApplicationPlugins()
+    .flatMap(
+      (plugin) =>
+        (
+          plugin as DSL_Mapping_LegendStudioApplicationPlugin_Extension
+        ).getExtraConnectionTypeOptions?.() ?? [],
+    );
+  const connectionOptions = Object.values(CONNECTION_TYPE)
+    .map((typeOption) => ({
+      label: prettyCONSTName(typeOption),
+      value: typeOption.toString(),
+    }))
+    .concat(extraOptionTypes);
   const onConnectionChange = (
-    val: { label: CONNECTION_TYPE; value: CONNECTION_TYPE } | null,
+    val: { label: string; value: string } | null,
   ): void => {
     if (val?.value && currentConnectionTypeOption.value !== val.value) {
       newConnectionDriver.changeConnectionState(val.value);
     }
   };
+
+  // store
+  const store = newConnectionDriver.store;
+  let storeOptions: { label: string; value?: Store | undefined }[] = [
+    { label: 'ModelStore', value: undefined },
+  ];
+  storeOptions = storeOptions.concat(
+    editorStore.graphManagerState.usableStores
+      .map(buildElementOption)
+      .slice()
+      .sort(compareLabelFn),
+  );
+  const selectedStoreOption = {
+    label: store.path,
+    value: store,
+  };
+  const onStoreSelectionChange = (val: { label: string; value: Store }): void =>
+    newConnectionDriver.setStore(val.value);
+
   return (
     <>
       <div className="panel__content__form__section__header__label">
@@ -327,6 +322,18 @@ const NewConnectionDriverEditor = observer(() => {
           darkMode={true}
         />
       </div>
+      <div className="panel__content__form__section__header__label">
+        Source Store
+      </div>
+      <div className="explorer__new-element-modal__driver">
+        <CustomSelectorInput
+          className="explorer__new-element-modal__driver__dropdown"
+          options={storeOptions}
+          onChange={onStoreSelectionChange}
+          value={selectedStoreOption}
+          darkMode={true}
+        />
+      </div>
       <NewConnectionValueDriverEditor />
     </>
   );

package/src/stores/DSL_Mapping_LegendStudioApplicationPlugin_Extension.ts

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+import type { PureGrammarTextSuggestion } from '@finos/legend-application';
 import type { DSL_LegendStudioApplicationPlugin_Extension } from './LegendStudioApplicationPlugin.js';
 import type { ConnectionValueState } from './editor-state/element-editor-state/connection/ConnectionEditorState.js';
 import type { EditorStore } from './EditorStore.js';
@@ -86,9 +87,16 @@ export type RuntimeConnectionTooltipTextBuilder = (
 
 export type NewConnectionDriverCreator = (
   editorStore: EditorStore,
-  store: Store,
+  typeOrStore: Store | string,
 ) => NewConnectionValueDriver<Connection> | undefined;
 
+export type ConnectionTypeOption = {
+  value: string;
+  label: string;
+};
+
+export type NewConnectionSnippetSuggestion = PureGrammarTextSuggestion;
+
 /**
  * @returns a boolean indicating whether the update has ocurred or not
  */
@@ -141,6 +149,11 @@ export interface DSL_Mapping_LegendStudioApplicationPlugin_Extension
    */
   getExtraMappingElementSourceExtractors?(): MappingElementSourceExtractor[];
 
+  /**
+   * Get extra connection type options.
+   */
+  getExtraConnectionTypeOptions?(): ConnectionTypeOption[];
+
   /**
    * Get the list of the default connection value builder for a specified store.
    */
@@ -166,6 +179,11 @@ export interface DSL_Mapping_LegendStudioApplicationPlugin_Extension
    */
   getExtraNewConnectionDriverCreators?(): NewConnectionDriverCreator[];
 
+  /**
+   * Get the list of creators for connection creation state driver given the store.
+   */
+  getExtraNewConnectionSnippetSuggestions?(): NewConnectionSnippetSuggestion[];
+
   /**
    * Get the list of instance set implementation source updaters.
    */

package/src/stores/editor/NewElementState.ts

@@ -228,9 +228,16 @@ export abstract class NewConnectionValueDriver<T extends Connection> {
   }
 
   abstract get isValid(): boolean;
+  abstract getConnectionType(): string;
   abstract createConnection(store: Store): T;
 }
 
+export enum CONNECTION_TYPE {
+  PURE_MODEL_CONNECTION = 'MODEL_CONNECTION',
+  FLAT_DATA_CONNECTION = 'FLAT_DATA_CONNECTION',
+  RELATIONAL_CONNECTION = 'RELATIONAL_CONNECTION',
+}
+
 export class NewPureModelConnectionDriver extends NewConnectionValueDriver<PureModelConnection> {
   class?: Class | undefined;
 
@@ -257,6 +264,10 @@ export class NewPureModelConnectionDriver extends NewConnectionValueDriver<PureM
     return Boolean(this.class);
   }
 
+  getConnectionType(): string {
+    return CONNECTION_TYPE.PURE_MODEL_CONNECTION;
+  }
+
   createConnection(store: ModelStore): PureModelConnection {
     return new JsonModelConnection(
       PackageableElementExplicitReference.create(store),
@@ -280,6 +291,10 @@ export class NewFlatDataConnectionDriver extends NewConnectionValueDriver<FlatDa
     return true;
   }
 
+  getConnectionType(): string {
+    return CONNECTION_TYPE.FLAT_DATA_CONNECTION;
+  }
+
   createConnection(store: FlatData): FlatDataConnection {
     return new FlatDataConnection(
       PackageableElementExplicitReference.create(store),
@@ -300,6 +315,10 @@ export class NewRelationalDatabaseConnectionDriver extends NewConnectionValueDri
     return true;
   }
 
+  getConnectionType(): string {
+    return CONNECTION_TYPE.RELATIONAL_CONNECTION;
+  }
+
   createConnection(store: Store): RelationalDatabaseConnection {
     let selectedStore: Database;
     if (store instanceof Database) {
@@ -317,22 +336,8 @@ export class NewRelationalDatabaseConnectionDriver extends NewConnectionValueDri
   }
 }
 
-export enum CONNECTION_TYPE {
-  RELATIONAL = 'RELATIONAL',
-  MODEL_CONNECTION = 'MODEL_CONNECTION',
-}
-
-const getConnectionType = (
-  val: NewConnectionValueDriver<Connection>,
-): CONNECTION_TYPE => {
-  if (val instanceof NewPureModelConnectionDriver) {
-    return CONNECTION_TYPE.MODEL_CONNECTION;
-  }
-  return CONNECTION_TYPE.RELATIONAL;
-};
-
 export class NewPackageableConnectionDriver extends NewElementDriver<PackageableConnection> {
-  store?: Store | undefined;
+  store: Store;
   newConnectionValueDriver: NewConnectionValueDriver<Connection>;
 
   constructor(editorStore: EditorStore) {
@@ -345,35 +350,59 @@ export class NewPackageableConnectionDriver extends NewElementDriver<Packageable
       changeConnectionState: action,
       isValid: computed,
     });
-
+    this.store = ModelStore.INSTANCE;
     this.newConnectionValueDriver =
-      this.getNewConnectionValueDriverBasedOnStore(undefined);
+      this.getNewConnectionValueDriverBasedOnStore(this.store);
   }
 
-  geDriverConnectionType(): CONNECTION_TYPE {
-    return getConnectionType(this.newConnectionValueDriver);
+  geDriverConnectionType(): string {
+    return this.newConnectionValueDriver.getConnectionType();
   }
 
-  changeConnectionState(val: CONNECTION_TYPE): void {
+  changeConnectionState(val: string): void {
     switch (val) {
-      case CONNECTION_TYPE.MODEL_CONNECTION:
+      case CONNECTION_TYPE.PURE_MODEL_CONNECTION:
         this.newConnectionValueDriver = new NewPureModelConnectionDriver(
           this.editorStore,
         );
         return;
-      case CONNECTION_TYPE.RELATIONAL:
+      case CONNECTION_TYPE.FLAT_DATA_CONNECTION:
+        this.newConnectionValueDriver = new NewFlatDataConnectionDriver(
+          this.editorStore,
+        );
+        return;
+      case CONNECTION_TYPE.RELATIONAL_CONNECTION:
         this.newConnectionValueDriver =
           new NewRelationalDatabaseConnectionDriver(this.editorStore);
         return;
-      default:
-        return;
+      default: {
+        const extraNewConnectionDriverCreators = this.editorStore.pluginManager
+          .getApplicationPlugins()
+          .flatMap(
+            (plugin) =>
+              (
+                plugin as DSL_Mapping_LegendStudioApplicationPlugin_Extension
+              ).getExtraNewConnectionDriverCreators?.() ?? [],
+          );
+        for (const creator of extraNewConnectionDriverCreators) {
+          const driver = creator(this.editorStore, val);
+          if (driver) {
+            this.newConnectionValueDriver = driver;
+            return;
+          }
+        }
+        throw new UnsupportedOperationError(
+          `Can't create new connection driver for type: no compatible creator available from plugins`,
+          val,
+        );
+      }
     }
   }
 
   getNewConnectionValueDriverBasedOnStore(
-    store: Store | undefined,
+    store: Store,
   ): NewConnectionValueDriver<Connection> {
-    if (store === undefined) {
+    if (store instanceof ModelStore) {
       return new NewPureModelConnectionDriver(this.editorStore);
     } else if (store instanceof FlatData) {
       return new NewFlatDataConnectionDriver(this.editorStore);
@@ -400,7 +429,7 @@ export class NewPackageableConnectionDriver extends NewElementDriver<Packageable
     );
   }
 
-  setStore(store: Store | undefined): void {
+  setStore(store: Store): void {
     this.store = store;
     this.newConnectionValueDriver =
       this.getNewConnectionValueDriverBasedOnStore(store);
@@ -414,7 +443,7 @@ export class NewPackageableConnectionDriver extends NewElementDriver<Packageable
     const connection = new PackageableConnection(name);
     packageableConnection_setConnectionValue(
       connection,
-      this.newConnectionValueDriver.createConnection(ModelStore.INSTANCE),
+      this.newConnectionValueDriver.createConnection(this.store),
       this.editorStore.changeDetectionState.observerContext,
     ); // default to model store
     return connection;

package/src/stores/editor-state/FileGenerationState.ts

@@ -51,7 +51,7 @@ import {
 } from '@finos/legend-graph';
 import {
   configurationProperty_setValue,
-  fileGeneration_addConfigurationProperty,
+  configurationProperty_addConfigurationProperty,
   fileGeneration_addScopeElement,
   fileGeneration_deleteScopeElement,
 } from '../shared/modifier/DSL_Generation_GraphModifierHelper.js';
@@ -294,7 +294,10 @@ export class FileGenerationState {
             generationProperty.name,
             newValue,
           );
-          fileGeneration_addConfigurationProperty(fileGeneration, newItem);
+          configurationProperty_addConfigurationProperty(
+            fileGeneration.configurationProperties,
+            newItem,
+          );
         }
       }
     } else {
@@ -317,7 +320,10 @@ export class FileGenerationState {
             generationProperty.name,
             newConfigValue,
           );
-          fileGeneration_addConfigurationProperty(fileGeneration, newItem);
+          configurationProperty_addConfigurationProperty(
+            fileGeneration.configurationProperties,
+            newItem,
+          );
         }
       } else {
         fileGeneration.configurationProperties =

package/src/stores/editor-state/ModelImporterState.ts

@@ -478,7 +478,7 @@ export class ModelImporterState extends EditorState {
   }
 
   override match(tab: EditorState): boolean {
-    return tab instanceof ModelImporterEditorState;
+    return tab instanceof ModelImporterState;
   }
 
   setReplaceFlag(val: boolean): void {

package/src/stores/editor-state/element-editor-state/external-format/DSL_ExternalFormat_SchemaSetEditorState.ts

@@ -27,7 +27,6 @@ import {
   readFileAsText,
   assertErrorThrown,
   LogEvent,
-  addUniqueEntry,
   deepEqual,
   guaranteeType,
   isEmpty,
@@ -55,7 +54,10 @@ import { type EntityChange, EntityChangeType } from '@finos/legend-server-sdlc';
 import type { EditorStore } from '../../../EditorStore.js';
 import { ElementEditorState } from '../ElementEditorState.js';
 import { LEGEND_STUDIO_APP_EVENT } from '../../../LegendStudioAppEvent.js';
-import { configurationProperty_setValue } from '../../../shared/modifier/DSL_Generation_GraphModifierHelper.js';
+import {
+  configurationProperty_addConfigurationProperty,
+  configurationProperty_setValue,
+} from '../../../shared/modifier/DSL_Generation_GraphModifierHelper.js';
 
 export enum SCHEMA_SET_TAB_TYPE {
   SCHEMAS = 'SCHEMAS',
@@ -92,8 +94,9 @@ export class SchemaSetModelGenerationState {
       setGenerationValue: action,
       setTargetBindingPath: action,
       handleTargetBindingPathChange: action,
+      updateGenerationParameters: action,
       canGenerate: computed,
-      generateModel: flow,
+      generate: flow,
       importGeneratedModelsIntoGraph: flow,
       getImportEntities: flow,
     });
@@ -197,7 +200,10 @@ export class SchemaSetModelGenerationState {
             generationProperty.name,
             newValue,
           );
-          addUniqueEntry(this.configurationProperties, newItem);
+          configurationProperty_addConfigurationProperty(
+            this.configurationProperties,
+            newItem,
+          );
         }
       }
     } else {
@@ -208,7 +214,8 @@ export class SchemaSetModelGenerationState {
           (generationProperty.defaultValue === 'true') ===
           (newValue as boolean);
       }
-      const newConfigValue = useDefaultValue ? undefined : newValue;
+      const newConfigValue =
+        useDefaultValue && !generationProperty.required ? undefined : newValue;
       if (newConfigValue !== undefined) {
         if (configProperty) {
           configurationProperty_setValue(configProperty, newConfigValue);
@@ -217,7 +224,10 @@ export class SchemaSetModelGenerationState {
             generationProperty.name,
             newConfigValue,
           );
-          addUniqueEntry(this.configurationProperties, newItem);
+          configurationProperty_addConfigurationProperty(
+            this.configurationProperties,
+            newItem,
+          );
         }
       } else {
         this.configurationProperties = this.configurationProperties.filter(
@@ -227,18 +237,37 @@ export class SchemaSetModelGenerationState {
     }
   }
 
-  *generateModel(): GeneratorFn<boolean> {
+  addInferredConfigurationProperties(
+    properties: ConfigurationProperty[],
+  ): void {
+    const modelGenerationProperties = this.modelGenerationProperties;
+    const SCHEMA_FORMAT_PROPERTY_NAME = 'format';
+    if (!properties.find((e) => e.name === SCHEMA_FORMAT_PROPERTY_NAME)) {
+      const genProperty = new ConfigurationProperty(
+        SCHEMA_FORMAT_PROPERTY_NAME,
+        this.schemaSet.format,
+      );
+      properties.push(genProperty);
+    }
+    modelGenerationProperties
+      .filter(
+        (property) =>
+          property.required &&
+          property.defaultValue &&
+          !properties.find((pv) => pv.name === property.name),
+      )
+      .forEach((toAdd) => {
+        const value = new ConfigurationProperty(toAdd.name, toAdd.defaultValue);
+        configurationProperty_addConfigurationProperty(properties, value);
+      });
+  }
+
+  *generate(): GeneratorFn<boolean> {
     this.generatingModelsState.inProgress();
+    this.editorStore.applicationStore.setNotification(undefined);
     try {
-      const SCHEMA_FORMAT_PROPERTY_NAME = 'format';
       const properties = [...this.configurationProperties];
-      if (!properties.find((e) => e.name === SCHEMA_FORMAT_PROPERTY_NAME)) {
-        const genProperty = new ConfigurationProperty(
-          SCHEMA_FORMAT_PROPERTY_NAME,
-          this.schemaSet.format,
-        );
-        properties.push(genProperty);
-      }
+      this.addInferredConfigurationProperties(properties);
       const val =
         (yield this.editorStore.graphManagerState.graphManager.generateModelFromExternalFormat(
           this.schemaSet,

package/src/stores/shared/modifier/DSL_Generation_GraphModifierHelper.ts

@@ -43,18 +43,19 @@ export const configurationProperty_setValue = action(
     cp.value = value;
   },
 );
-export const fileGeneration_setType = action(
-  (fg: FileGenerationSpecification, value: string): void => {
-    fg.type = value;
+
+export const configurationProperty_addConfigurationProperty = action(
+  (
+    configurationProperties: ConfigurationProperty[],
+    cp: ConfigurationProperty,
+  ): void => {
+    addUniqueEntry(configurationProperties, observe_ConfigurationProperty(cp));
   },
 );
 
-export const fileGeneration_addConfigurationProperty = action(
-  (fg: FileGenerationSpecification, cp: ConfigurationProperty): void => {
-    addUniqueEntry(
-      fg.configurationProperties,
-      observe_ConfigurationProperty(cp),
-    );
+export const fileGeneration_setType = action(
+  (fg: FileGenerationSpecification, value: string): void => {
+    fg.type = value;
   },
 );