@finos/legend-application-studio 13.0.3 → 13.1.2

package/src/stores/EditorStore.ts

@@ -117,6 +117,7 @@ import {
   PRIMITIVE_TYPE,
   Package,
   DataElement,
+  isElementReadOnly,
 } from '@finos/legend-graph';
 import type { DepotServerClient } from '@finos/legend-server-depot';
 import type { LegendStudioPluginManager } from '../application/LegendStudioPluginManager.js';
@@ -1121,7 +1122,7 @@ export class EditorStore {
   *deleteElement(element: PackageableElement): GeneratorFn<void> {
     if (
       this.graphState.checkIfApplicationUpdateOperationIsRunning() ||
-      this.graphManagerState.isElementReadOnly(element)
+      isElementReadOnly(element)
     ) {
       return;
     }
@@ -1187,7 +1188,7 @@ export class EditorStore {
     element: PackageableElement,
     newPath: string,
   ): GeneratorFn<void> {
-    if (this.graphManagerState.isElementReadOnly(element)) {
+    if (isElementReadOnly(element)) {
       return;
     }
     graph_renameElement(
@@ -1354,7 +1355,7 @@ export class EditorStore {
   get classOptions(): PackageableElementOption<Class>[] {
     return this.graphManagerState.graph.ownClasses
       .concat(
-        this.graphManagerState.filterSystemElementOptions(
+        this.graphManagerState.collectExposedSystemElements(
           this.graphManagerState.graph.systemModel.ownClasses,
         ),
       )
@@ -1365,7 +1366,7 @@ export class EditorStore {
   get associationOptions(): PackageableElementOption<Association>[] {
     return this.graphManagerState.graph.ownAssociations
       .concat(
-        this.graphManagerState.filterSystemElementOptions(
+        this.graphManagerState.collectExposedSystemElements(
           this.graphManagerState.graph.systemModel.ownAssociations,
         ),
       )
@@ -1376,7 +1377,7 @@ export class EditorStore {
   get profileOptions(): PackageableElementOption<Profile>[] {
     return this.graphManagerState.graph.ownProfiles
       .concat(
-        this.graphManagerState.filterSystemElementOptions(
+        this.graphManagerState.collectExposedSystemElements(
           this.graphManagerState.graph.systemModel.ownProfiles,
         ),
       )
@@ -1391,7 +1392,7 @@ export class EditorStore {
       .concat(
         this.graphManagerState.graph.ownTypes
           .concat(
-            this.graphManagerState.filterSystemElementOptions(
+            this.graphManagerState.collectExposedSystemElements(
               this.graphManagerState.graph.systemModel.ownTypes,
             ),
           )

package/src/stores/editor/NewElementState.ts

@@ -190,7 +190,7 @@ export class NewPackageableRuntimeDriver extends NewElementDriver<PackageableRun
       isValid: computed,
     });
 
-    const mappings = this.editorStore.graphManagerState.graph.ownMappings;
+    const mappings = this.editorStore.graphManagerState.graph.mappings;
     if (mappings.length) {
       this.mapping = mappings[0];
     }
@@ -240,7 +240,7 @@ export class NewPureModelConnectionDriver extends NewConnectionValueDriver<PureM
       isValid: computed,
     });
 
-    const classes = this.editorStore.graphManagerState.graph.ownClasses;
+    const classes = this.editorStore.graphManagerState.graph.classes;
     if (classes.length) {
       this.class = classes[0];
     }
@@ -302,7 +302,7 @@ export class NewRelationalDatabaseConnectionDriver extends NewConnectionValueDri
     if (store instanceof Database) {
       selectedStore = store;
     } else {
-      const dbs = this.editorStore.graphManagerState.graph.ownDatabases;
+      const dbs = this.editorStore.graphManagerState.graph.databases;
       selectedStore = dbs.length ? (dbs[0] as Database) : stub_Database();
     }
     return new RelationalDatabaseConnection(
@@ -533,6 +533,7 @@ export class NewGenerationSpecificationDriver extends NewElementDriver<Generatio
   }
 
   get isValid(): boolean {
+    // only one generation specification should exist
     return !this.editorStore.graphManagerState.graph.ownGenerationSpecifications
       .length;
   }
@@ -758,8 +759,8 @@ export class NewElementState {
         element = new Profile(name);
         break;
       // default for function -> return type: String, return Multiplicity 1
-      case PACKAGEABLE_ELEMENT_TYPE.FUNCTION:
-        element = new ConcreteFunctionDefinition(
+      case PACKAGEABLE_ELEMENT_TYPE.FUNCTION: {
+        const fn = new ConcreteFunctionDefinition(
           name,
           PackageableElementExplicitReference.create(
             this.editorStore.graphManagerState.graph.getPrimitiveType(
@@ -770,7 +771,13 @@ export class NewElementState {
             TYPICAL_MULTIPLICITY_TYPE.ONE,
           ),
         );
+        // default to empty string
+        fn.expressionSequence =
+          this.editorStore.graphManagerState.graphManager.createDefaultBasicRawLambda()
+            .body as object[];
+        element = fn;
         break;
+      }
       case PACKAGEABLE_ELEMENT_TYPE.MAPPING:
         element = new Mapping(name);
         break;

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

@@ -22,13 +22,7 @@ import {
   deleteEntry,
   guaranteeNonNullable,
 } from '@finos/legend-shared';
-import {
-  computed,
-  observable,
-  makeObservable,
-  makeAutoObservable,
-  action,
-} from 'mobx';
+import { computed, observable, makeObservable, action } from 'mobx';
 import type { EditorStore } from '../EditorStore.js';
 import {
   GenerationSpecification,
@@ -48,18 +42,10 @@ export type GenerationSpecNodeDropTarget = GenerationSpecNodeDragSource;
 export class GenerationTreeNodeState {
   readonly uuid = uuid();
   node: GenerationTreeNode;
-  isBeingDragged = false;
 
   constructor(node: GenerationTreeNode) {
-    makeAutoObservable(this, {
-      setIsBeingDragged: action,
-    });
     this.node = node;
   }
-
-  setIsBeingDragged(val: boolean): void {
-    this.isBeingDragged = val;
-  }
 }
 
 export class GenerationSpecificationEditorState extends ElementEditorState {

package/src/stores/editor-state/element-editor-state/ElementEditorState.ts

@@ -27,6 +27,7 @@ import {
   type CompilationError,
   type PackageableElement,
   GRAPH_MANAGER_EVENT,
+  isElementReadOnly,
 } from '@finos/legend-graph';
 import { TAB_SIZE } from '@finos/legend-application';
 
@@ -61,9 +62,7 @@ export abstract class ElementEditorState extends EditorState {
     });
 
     this.element = element;
-    this.isReadOnly =
-      editorStore.graphManagerState.isElementReadOnly(element) ||
-      editorStore.isInViewerMode;
+    this.isReadOnly = isElementReadOnly(element) || editorStore.isInViewerMode;
   }
 
   get headerName(): string {

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

@@ -42,6 +42,7 @@ import {
   SnowflakePublicAuthenticationStrategy,
   GCPApplicationDefaultCredentialsAuthenticationStrategy,
   GCPWorkloadIdentityFederationAuthenticationStrategy,
+  MiddleTierUsernamePasswordAuthenticationStrategy,
   EmbeddedH2DatasourceSpecification,
   LocalH2DatasourceSpecification,
   DatabricksDatasourceSpecification,
@@ -94,6 +95,7 @@ export enum CORE_AUTHENTICATION_STRATEGY_TYPE {
   OAUTH = 'OAUTH',
   USERNAME_PASSWORD = 'USERNAME_PASSWORD',
   GCP_WORKLOAD_IDENTITY_FEDERATION = 'GCP_WORKLOAD_IDENTITY_FEDERATION',
+  MIDDLE_TIER_USERNAME_PASSWORD = 'MIDDLE_TIER_USERNAME_PASSWORD',
 }
 
 export class RelationalDatabaseConnectionValueState extends ConnectionValueState {
@@ -262,6 +264,10 @@ export class RelationalDatabaseConnectionValueState extends ConnectionValueState
       auth instanceof GCPWorkloadIdentityFederationAuthenticationStrategy
     ) {
       return CORE_AUTHENTICATION_STRATEGY_TYPE.GCP_WORKLOAD_IDENTITY_FEDERATION;
+    } else if (
+      auth instanceof MiddleTierUsernamePasswordAuthenticationStrategy
+    ) {
+      return CORE_AUTHENTICATION_STRATEGY_TYPE.MIDDLE_TIER_USERNAME_PASSWORD;
     }
 
     const extraAuthenticationStrategyTypeGetters =
@@ -326,6 +332,10 @@ export class RelationalDatabaseConnectionValueState extends ConnectionValueState
         authStrategy = new OAuthAuthenticationStrategy('', '');
         break;
       }
+      case CORE_AUTHENTICATION_STRATEGY_TYPE.MIDDLE_TIER_USERNAME_PASSWORD: {
+        authStrategy = new MiddleTierUsernamePasswordAuthenticationStrategy('');
+        break;
+      }
       default: {
         const extraAuthenticationStrategyCreators =
           this.editorStore.pluginManager

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

@@ -1468,7 +1468,7 @@ export class MappingEditorState extends ElementEditorState {
 
   *createNewTest(setImplementation: SetImplementation): GeneratorFn<void> {
     const query =
-      this.editorStore.graphManagerState.graphManager.HACKY__createGetAllLambda(
+      this.editorStore.graphManagerState.graphManager.createGetAllRawLambda(
         setImplementation.class.value,
       );
     const source = getMappingElementSource(

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

@@ -834,7 +834,7 @@ export class MappingExecutionState {
     yield flowResult(
       this.queryState.updateLamba(
         setImplementation
-          ? this.editorStore.graphManagerState.graphManager.HACKY__createGetAllLambda(
+          ? this.editorStore.graphManagerState.graphManager.createGetAllRawLambda(
               guaranteeType(getMappingElementTarget(setImplementation), Class),
             )
           : stub_RawLambda(),

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

@@ -125,6 +125,7 @@ export class ServiceExecutionParameterState extends LambdaParametersState {
       const parmeterState = new LambdaParameterState(
         p,
         this.executionState.editorStore.changeDetectionState.observerContext,
+        this.executionState.editorStore.graphManagerState.graph,
       );
       parmeterState.mockParameterValue();
       return parmeterState;

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

@@ -44,6 +44,7 @@ import {
   isNonNullable,
   returnUndefOnError,
   getNullableFirstElement,
+  uniq,
 } from '@finos/legend-shared';
 import { action, flow, makeObservable, observable } from 'mobx';
 import type { EditorStore } from '../../../../EditorStore.js';
@@ -360,6 +361,6 @@ export class ServiceTestDataState {
     } else if (execution instanceof PureMultiExecution) {
       runtimes = execution.executionParameters.map((t) => t.runtime);
     }
-    return runtimes.flatMap(getAllIdentifiedConnectionsFromRuntime);
+    return uniq(runtimes.flatMap(getAllIdentifiedConnectionsFromRuntime));
   }
 }

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

@@ -136,7 +136,10 @@ export class ServiceValueSpecificationTestParameterState extends ServiceTestPara
   }
 
   resetValueSpec(): void {
-    const mockValue = generateVariableExpressionMockValue(this.varExpression);
+    const mockValue = generateVariableExpressionMockValue(
+      this.varExpression,
+      this.editorStore.graphManagerState.graph,
+    );
     if (mockValue) {
       this.updateValueSpecification(mockValue);
     }
@@ -258,7 +261,10 @@ export class ServiceTestSetupState {
   addExpressionParameterValue(expression: VariableExpression): void {
     try {
       const mockValue = guaranteeNonNullable(
-        generateVariableExpressionMockValue(expression),
+        generateVariableExpressionMockValue(
+          expression,
+          this.editorStore.graphManagerState.graph,
+        ),
       );
       const paramValue = new ParameterValue();
       paramValue.name = expression.name;
@@ -338,7 +344,10 @@ export class ServiceTestSetupState {
       const varExpressions = this.queryVariableExpressions;
       const parameterValueStates = varExpressions
         .map((varExpression) => {
-          const mockValue = generateVariableExpressionMockValue(varExpression);
+          const mockValue = generateVariableExpressionMockValue(
+            varExpression,
+            this.editorStore.graphManagerState.graph,
+          );
           if (mockValue) {
             const paramValue = new ParameterValue();
             paramValue.name = varExpression.name;

package/src/stores/graphModifier/DomainGraphModifierHelper.ts

@@ -19,6 +19,7 @@ import {
   assertTrue,
   deleteEntry,
   guaranteeType,
+  swapEntry,
 } from '@finos/legend-shared';
 import { action } from 'mobx';
 import {
@@ -90,6 +91,12 @@ export const class_addProperty = action(
   },
 );
 
+export const class_swapProperties = action(
+  (_class: Class, sourceProperty: Property, targetProperty: Property): void => {
+    swapEntry(_class.properties, sourceProperty, targetProperty);
+  },
+);
+
 export const class_deleteDerivedProperty = action(
   (_class: Class, val: DerivedProperty): void => {
     deleteEntry(_class.derivedProperties, val);
@@ -100,6 +107,17 @@ export const class_addDerivedProperty = action(
     addUniqueEntry(_class.derivedProperties, observe_DerivedProperty(val));
   },
 );
+
+export const class_swapDerivedProperties = action(
+  (
+    _class: Class,
+    sourceProperty: DerivedProperty,
+    targetProperty: DerivedProperty,
+  ): void => {
+    swapEntry(_class.derivedProperties, sourceProperty, targetProperty);
+  },
+);
+
 export const class_addContraint = action(
   (_class: Class, val: Constraint): void => {
     addUniqueEntry(_class.constraints, observe_Constraint(val));
@@ -110,6 +128,16 @@ export const class_deleteConstraint = action(
     deleteEntry(_class.constraints, val);
   },
 );
+export const class_swapConstraints = action(
+  (
+    _class: Class,
+    sourceConstraint: Constraint,
+    targetConstraint: Constraint,
+  ): void => {
+    swapEntry(_class.constraints, sourceConstraint, targetConstraint);
+  },
+);
+
 export const class_addSuperType = action(
   (_class: Class, val: GenericTypeReference): void => {
     addUniqueEntry(_class.generalizations, observe_GenericTypeReference(val));
@@ -120,6 +148,15 @@ export const class_deleteSuperType = action(
     deleteEntry(_class.generalizations, val);
   },
 );
+export const class_swapSuperTypes = action(
+  (
+    _class: Class,
+    sourceSuperType: GenericTypeReference,
+    targetSuperType: GenericTypeReference,
+  ): void => {
+    swapEntry(_class.generalizations, sourceSuperType, targetSuperType);
+  },
+);
 export const class_addSubclass = action((_class: Class, val: Class): void => {
   addUniqueEntry(_class._subclasses, val);
 });
@@ -211,6 +248,30 @@ export const tagStereotype_setValue = action(
   },
 );
 
+export const annotatedElement_swapTaggedValues = action(
+  (
+    annotatedElement: AnnotatedElement,
+    sourceTaggedValue: TaggedValue,
+    targetTaggedValue: TaggedValue,
+  ): void => {
+    swapEntry(
+      annotatedElement.taggedValues,
+      sourceTaggedValue,
+      targetTaggedValue,
+    );
+  },
+);
+
+export const annotatedElement_swapStereotypes = action(
+  (
+    annotatedElement: AnnotatedElement,
+    sourceStereotype: StereotypeReference,
+    targetStereotype: StereotypeReference,
+  ): void => {
+    swapEntry(annotatedElement.stereotypes, sourceStereotype, targetStereotype);
+  },
+);
+
 // --------------------------------------------- DerivedProperty -------------------------------------
 
 export const derivedProperty_setBody = (
@@ -260,6 +321,22 @@ export const profile_deleteStereotype = action(
   },
 );
 
+export const profile_swapTags = action(
+  (profile: Profile, sourceTag: Tag, targetTag: Tag): void => {
+    swapEntry(profile.p_tags, sourceTag, targetTag);
+  },
+);
+
+export const profile_swapStereotypes = action(
+  (
+    profile: Profile,
+    sourceStereotype: Stereotype,
+    targetStereotype: Stereotype,
+  ): void => {
+    swapEntry(profile.p_stereotypes, sourceStereotype, targetStereotype);
+  },
+);
+
 // --------------------------------------------- Function -------------------------------------
 
 export const function_deleteParameter = action(
@@ -283,6 +360,16 @@ export const function_setReturnMultiplicity = action(
   },
 );
 
+export const function_swapParameters = action(
+  (
+    _func: ConcreteFunctionDefinition,
+    sourceParameter: RawVariableExpression,
+    targetParameter: RawVariableExpression,
+  ): void => {
+    swapEntry(_func.parameters, sourceParameter, targetParameter);
+  },
+);
+
 // --------------------------------------------- Enumeration -------------------------------------
 
 export const enum_setName = action((val: Enum, value: string): void => {
@@ -298,6 +385,11 @@ export const enum_deleteValue = action(
     deleteEntry(enumeration.values, value);
   },
 );
+export const enum_swapValues = action(
+  (enumeration: Enumeration, sourceEnum: Enum, targetEnum: Enum): void => {
+    swapEntry(enumeration.values, sourceEnum, targetEnum);
+  },
+);
 export const enumValueReference_setValue = action(
   (ref: EnumValueReference, value: Enum): void => {
     ref.value = observe_Enum(value);

package/src/stores/graphModifier/StoreRelational_GraphModifierHelper.ts

@@ -38,6 +38,7 @@ import {
   type StaticDatasourceSpecification,
   type UsernamePasswordAuthenticationStrategy,
   type GCPWorkloadIdentityFederationAuthenticationStrategy,
+  type MiddleTierUsernamePasswordAuthenticationStrategy,
   type ObserverContext,
   type EnumerationMappingReference,
   type TableAlias,
@@ -163,6 +164,15 @@ export const gcpWorkloadIdentityFederationAuthenticationStrategy_setAdditionalGc
     },
   );
 
+export const middleTierUsernamePasswordAuthenticationStrategy_setVaultReference =
+  action(
+    (
+      v: MiddleTierUsernamePasswordAuthenticationStrategy,
+      val: string,
+    ): void => {
+      v.vaultReference = val;
+    },
+  );
 // --------------------------------------------- DatasourceSpecification -------------------------------------
 export const staticDatasourceSpecification_setHost = action(
   (v: StaticDatasourceSpecification, val: string): void => {

package/src/stores/shared/DnDUtil.ts

@@ -49,8 +49,6 @@ export enum CORE_DND_TYPE {
   MAPPING_EXPLORER_CLASS_MAPPING = 'MAPPING_EXPLORER_CLASS_MAPPING',
   MAPPING_EXPLORER_ENUMERATION_MAPPING = 'MAPPING_EXPLORER_ENUMERATION_MAPPING',
   MAPPING_EXPLORER_ASSOCIATION_MAPPING = 'MAPPING_EXPLORER_ASSOCIATION_MAPPING',
-  // gen spec node
-  GENERATION_SPEC_NODE = 'GENERATION_SPEC_NODE',
 }
 
 // React DnD uses Redux under the hood and also it champions the use of plain object over class instance

package/src/stores/shared/testable/TestableUtils.ts

@@ -63,13 +63,14 @@ export const getAllIdentifiedConnectionsFromRuntime = (
 ): IdentifiedConnection[] => {
   const resolvedRuntimes: EngineRuntime[] = [];
   if (runtime instanceof RuntimePointer) {
-    const engineRuntime = runtime.packageableRuntime.value.runtimeValue;
-    resolvedRuntimes.push(engineRuntime);
+    resolvedRuntimes.push(runtime.packageableRuntime.value.runtimeValue);
   } else if (runtime instanceof EngineRuntime) {
     resolvedRuntimes.push(runtime);
   }
   return resolvedRuntimes
-    .flatMap((e) => e.connections.map((l) => l.storeConnections))
+    .flatMap((e) =>
+      e.connections.map((connection) => connection.storeConnections),
+    )
     .flat();
 };