@finos/legend-application-studio 13.0.1 → 13.1.0

package/src/components/workspace-setup/WorkspaceSetup.tsx

@@ -70,7 +70,7 @@ const CreateWorkspaceModal = observer(() => {
     setupStore.currentProjectId,
   );
   const [workspaceName, setWorkspaceName] = useState('');
-  const [isGroupWorkspace, setIsGroupWorkspace] = useState<boolean>(false);
+  const [isGroupWorkspace, setIsGroupWorkspace] = useState<boolean>(true);
   const workspaceType = isGroupWorkspace
     ? WorkspaceType.GROUP
     : WorkspaceType.USER;

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

@@ -758,8 +758,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 +770,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/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/mapping/MappingTestState.ts

@@ -412,6 +412,7 @@ export class MappingTestState {
   assertionState: MappingTestAssertionState;
   isGeneratingPlan = false;
   executionPlanState: ExecutionPlanState;
+  testRunPromise: Promise<ExecutionResult> | undefined = undefined;
 
   constructor(
     editorStore: EditorStore,
@@ -423,6 +424,7 @@ export class MappingTestState {
       editorStore: false,
       mappingEditorState: false,
       executionPlanState: false,
+      setIsRunningTest: action,
       setSelectedTab: action,
       resetTestRunStatus: action,
       setResult: action,
@@ -447,10 +449,18 @@ export class MappingTestState {
     );
   }
 
+  setIsRunningTest(val: boolean): void {
+    this.isRunningTest = val;
+  }
+
   setSelectedTab(val: MAPPING_TEST_EDITOR_TAB_TYPE): void {
     this.selectedTab = val;
   }
 
+  setTestRunPromise = (promise: Promise<ExecutionResult> | undefined): void => {
+    this.testRunPromise = promise;
+  };
+
   buildQueryState(): MappingTestQueryState {
     const queryState = new MappingTestQueryState(
       this.editorStore,
@@ -674,52 +684,59 @@ export class MappingTestState {
       return;
     }
     const startTime = Date.now();
+    let promise;
     try {
       const runtime = this.inputDataState.runtime;
       this.isRunningTest = true;
-      const result =
-        (yield this.editorStore.graphManagerState.graphManager.executeMapping(
-          this.test.query,
-          this.mappingEditorState.mapping,
-          runtime,
-          this.editorStore.graphManagerState.graph,
-          {
-            useLosslessParse: true,
-          },
-        )) as ExecutionResult;
-      this.testExecutionResultText = losslessStringify(
-        extractExecutionResultValues(result),
-        undefined,
-        TAB_SIZE,
+      promise = this.editorStore.graphManagerState.graphManager.executeMapping(
+        this.test.query,
+        this.mappingEditorState.mapping,
+        runtime,
+        this.editorStore.graphManagerState.graph,
+        {
+          useLosslessParse: true,
+        },
       );
-      let assertionMatched = false;
-      if (
-        this.assertionState instanceof MappingTestExpectedOutputAssertionState
-      ) {
-        // TODO: this logic should probably be better handled in by engine mapping test runner
-        assertionMatched =
-          hashObject(extractExecutionResultValues(result)) ===
-          hashObject(losslessParse(this.assertionState.expectedResult));
-      } else {
-        throw new UnsupportedOperationError();
+      this.setTestRunPromise(promise);
+      const result = (yield promise) as ExecutionResult;
+      if (this.testRunPromise === promise) {
+        this.testExecutionResultText = losslessStringify(
+          extractExecutionResultValues(result),
+          undefined,
+          TAB_SIZE,
+        );
+        let assertionMatched = false;
+        if (
+          this.assertionState instanceof MappingTestExpectedOutputAssertionState
+        ) {
+          // TODO: this logic should probably be better handled in by engine mapping test runner
+          assertionMatched =
+            hashObject(extractExecutionResultValues(result)) ===
+            hashObject(losslessParse(this.assertionState.expectedResult));
+        } else {
+          throw new UnsupportedOperationError();
+        }
+        this.setResult(
+          assertionMatched ? TEST_RESULT.PASSED : TEST_RESULT.FAILED,
+        );
       }
-      this.setResult(
-        assertionMatched ? TEST_RESULT.PASSED : TEST_RESULT.FAILED,
-      );
     } catch (error) {
       assertErrorThrown(error);
       this.editorStore.applicationStore.log.error(
         LogEvent.create(GRAPH_MANAGER_EVENT.EXECUTION_FAILURE),
         error,
       );
-      this.errorRunningTest = error;
-      this.setResult(TEST_RESULT.ERROR);
+      if (this.testRunPromise === promise) {
+        this.errorRunningTest = error;
+        this.setResult(TEST_RESULT.ERROR);
+      }
     } finally {
       this.isRunningTest = false;
       this.runTime = Date.now() - startTime;
       // if the test is currently opened and ran but did not pass, switch to the result tab
       if (
         [TEST_RESULT.FAILED, TEST_RESULT.ERROR].includes(this.result) &&
+        this.testRunPromise === promise &&
         this.mappingEditorState.currentTabState === this
       ) {
         this.setSelectedTab(MAPPING_TEST_EDITOR_TAB_TYPE.RESULT);

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

@@ -102,7 +102,7 @@ export class ServiceExecutionParameterState extends LambdaParametersState {
     this.parameterStates = this.build(query);
     this.parameterValuesEditorState.open(
       (): Promise<void> =>
-        flowResult(this.executionState.execute()).catch(
+        flowResult(this.executionState.runQuery()).catch(
           this.executionState.editorStore.applicationStore.alertUnhandledError,
         ),
       PARAMETER_SUBMIT_ACTION.EXECUTE,
@@ -440,13 +440,14 @@ export abstract class ServicePureExecutionState extends ServiceExecutionState {
   declare execution: PureExecution;
   selectedExecutionContextState: ServiceExecutionContextState | undefined;
   runtimeEditorState?: RuntimeEditorState | undefined;
-  isExecuting = false;
+  isRunningQuery = false;
   isGeneratingPlan = false;
   isOpeningQueryEditor = false;
   executionResultText?: string | undefined; // NOTE: stored as lossless JSON string
   executionPlanState: ExecutionPlanState;
   parameterState: ServiceExecutionParameterState;
   showChangeExecModal = false;
+  queryRunPromise: Promise<ExecutionResult> | undefined = undefined;
 
   constructor(
     editorStore: EditorStore,
@@ -473,6 +474,10 @@ export abstract class ServicePureExecutionState extends ServiceExecutionState {
     return false;
   }
 
+  setIsRunningQuery(val: boolean): void {
+    this.isRunningQuery = val;
+  }
+
   setShowChangeExecModal(val: boolean): void {
     this.showChangeExecModal = val;
   }
@@ -480,13 +485,21 @@ export abstract class ServicePureExecutionState extends ServiceExecutionState {
   setOpeningQueryEditor(val: boolean): void {
     this.isOpeningQueryEditor = val;
   }
+
   setExecutionResultText = (executionResult: string | undefined): void => {
     this.executionResultText = executionResult;
   };
+
   setQueryState = (queryState: ServicePureExecutionQueryState): void => {
     this.queryState = queryState;
   };
 
+  setQueryRunPromise = (
+    promise: Promise<ExecutionResult> | undefined,
+  ): void => {
+    this.queryRunPromise = promise;
+  };
+
   *generatePlan(debug: boolean): GeneratorFn<void> {
     if (!this.selectedExecutionContextState || this.isGeneratingPlan) {
       return;
@@ -538,7 +551,7 @@ export abstract class ServicePureExecutionState extends ServiceExecutionState {
   }
 
   *handleExecute(): GeneratorFn<void> {
-    if (!this.selectedExecutionContextState || this.isExecuting) {
+    if (!this.selectedExecutionContextState || this.isRunningQuery) {
       return;
     }
     const query = this.queryState.query;
@@ -546,19 +559,19 @@ export abstract class ServicePureExecutionState extends ServiceExecutionState {
     if (parameters.length) {
       this.parameterState.openModal(query);
     } else {
-      this.execute();
+      this.runQuery();
     }
   }
 
-  *execute(): GeneratorFn<void> {
-    if (!this.selectedExecutionContextState || this.isExecuting) {
+  *runQuery(): GeneratorFn<void> {
+    if (!this.selectedExecutionContextState || this.isRunningQuery) {
       return;
     }
     try {
-      this.isExecuting = true;
+      this.isRunningQuery = true;
       const query = this.getExecutionQuery();
-      const result =
-        (yield this.editorStore.graphManagerState.graphManager.executeMapping(
+      const promise =
+        this.editorStore.graphManagerState.graphManager.executeMapping(
           query,
           this.selectedExecutionContextState.executionContext.mapping.value,
           this.selectedExecutionContextState.executionContext.runtime,
@@ -566,11 +579,15 @@ export abstract class ServicePureExecutionState extends ServiceExecutionState {
           {
             useLosslessParse: true,
           },
-        )) as ExecutionResult;
-      this.setExecutionResultText(
-        losslessStringify(result, undefined, TAB_SIZE),
-      );
-      this.parameterState.setParameters([]);
+        );
+      this.setQueryRunPromise(promise);
+      const result = (yield promise) as ExecutionResult;
+      if (this.queryRunPromise === promise) {
+        this.setExecutionResultText(
+          losslessStringify(result, undefined, TAB_SIZE),
+        );
+        this.parameterState.setParameters([]);
+      }
     } catch (error) {
       assertErrorThrown(error);
       this.editorStore.applicationStore.log.error(
@@ -579,7 +596,7 @@ export abstract class ServicePureExecutionState extends ServiceExecutionState {
       );
       this.editorStore.applicationStore.notifyError(error);
     } finally {
-      this.isExecuting = false;
+      this.isRunningQuery = false;
     }
   }
 
@@ -611,7 +628,7 @@ export abstract class ServicePureExecutionState extends ServiceExecutionState {
   get serviceExecutionParameters():
     | { query: RawLambda; mapping: Mapping; runtime: Runtime }
     | undefined {
-    if (!this.selectedExecutionContextState || this.isExecuting) {
+    if (!this.selectedExecutionContextState || this.isRunningQuery) {
       return undefined;
     }
     const query = this.queryState.query;
@@ -701,7 +718,7 @@ export class SingleServicePureExecutionState extends ServicePureExecutionState {
       queryState: observable,
       getInitiallySelectedExecutionContextState: observable,
       runtimeEditorState: observable,
-      isExecuting: observable,
+      isRunningQuery: observable,
       isGeneratingPlan: observable,
       isOpeningQueryEditor: observable,
       executionResultText: observable,
@@ -720,9 +737,10 @@ export class SingleServicePureExecutionState extends ServicePureExecutionState {
       changeExecution: action,
       setMultiExecutionKey: action,
       setShowChangeExecModal: action,
+      setIsRunningQuery: action,
       generatePlan: flow,
       handleExecute: flow,
-      execute: flow,
+      runQuery: flow,
     });
     this.selectedExecutionContextState =
       this.getInitiallySelectedExecutionContextState();
@@ -778,7 +796,7 @@ export class MultiServicePureExecutionState extends ServicePureExecutionState {
       queryState: observable,
       selectedExecutionContextState: observable,
       runtimeEditorState: observable,
-      isExecuting: observable,
+      isRunningQuery: observable,
       isGeneratingPlan: observable,
       isOpeningQueryEditor: observable,
       executionResultText: observable,
@@ -804,9 +822,10 @@ export class MultiServicePureExecutionState extends ServicePureExecutionState {
       changeKeyValue: action,
       setSingleExecutionKey: action,
       setShowChangeExecModal: action,
+      setIsRunningQuery: action,
       changeExecution: action,
       generatePlan: flow,
-      execute: flow,
+      runQuery: flow,
     });
 
     this.execution = execution;

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

@@ -237,7 +237,7 @@ export class ServiceRegistrationState {
         serviceRegistrationResult.pattern,
         'Service registration pattern is missing',
       );
-      const message = `Service with patten ${
+      const message = `Service with pattern ${
         serviceRegistrationResult.pattern
       } registered ${this.activatePostRegistration ? 'and activated ' : ''}`;
       const encodedServicePattern =

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/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