@finos/legend-application-studio 13.0.2 → 13.1.1

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/LegendStudioBaseStore.ts

@@ -14,31 +14,14 @@
  * limitations under the License.
  */
 
-import {
-  type GeneratorFn,
-  type PlainObject,
-  HttpStatus,
-  NetworkClientError,
-  ActionState,
-  LogEvent,
-  assertErrorThrown,
-} from '@finos/legend-shared';
+import { type GeneratorFn, ActionState } from '@finos/legend-shared';
 import {
   type ApplicationStore,
-  ActionAlertActionType,
-  ActionAlertType,
   ApplicationTelemetry,
+  LegendApplicationSDLCSetupState,
 } from '@finos/legend-application';
-import {
-  action,
-  computed,
-  flow,
-  flowResult,
-  makeObservable,
-  observable,
-} from 'mobx';
-import { User, SDLCServerClient } from '@finos/legend-server-sdlc';
-import { LEGEND_STUDIO_APP_EVENT } from './LegendStudioAppEvent.js';
+import { flow, flowResult, makeObservable } from 'mobx';
+import type { SDLCServerClient } from '@finos/legend-server-sdlc';
 import type { DepotServerClient } from '@finos/legend-server-depot';
 import type { LegendStudioPluginManager } from '../application/LegendStudioPluginManager.js';
 import type { LegendStudioApplicationConfig } from '../application/LegendStudioApplicationConfig.js';
@@ -54,14 +37,11 @@ export type LegendStudioApplicationStore = ApplicationStore<
 
 export class LegendStudioBaseStore {
   applicationStore: LegendStudioApplicationStore;
-  sdlcServerClient: SDLCServerClient;
   depotServerClient: DepotServerClient;
   pluginManager: LegendStudioPluginManager;
 
   initState = ActionState.create();
-
-  isSDLCAuthorized = false;
-  SDLCServerTermsOfServicesUrlsToView: string[] = [];
+  applicationSDLCSetupState: LegendApplicationSDLCSetupState;
 
   constructor(
     applicationStore: LegendStudioApplicationStore,
@@ -69,23 +49,23 @@ export class LegendStudioBaseStore {
     depotServerClient: DepotServerClient,
     pluginManager: LegendStudioPluginManager,
   ) {
-    makeObservable<LegendStudioBaseStore, 'initializeSDLCServerClient'>(this, {
-      isSDLCAuthorized: observable,
-      SDLCServerTermsOfServicesUrlsToView: observable,
-      needsToAcceptSDLCServerTermsOfServices: computed,
+    makeObservable(this, {
       initialize: flow,
-      initializeSDLCServerClient: flow,
-      dismissSDLCServerTermsOfServicesAlert: action,
     });
 
     this.applicationStore = applicationStore;
-    this.sdlcServerClient = sdlcServerClient;
+    this.applicationSDLCSetupState = new LegendApplicationSDLCSetupState(
+      applicationStore,
+      sdlcServerClient,
+    );
     this.depotServerClient = depotServerClient;
 
     this.pluginManager = pluginManager;
 
     // Register plugins
-    this.sdlcServerClient.setTracerService(this.applicationStore.tracerService);
+    this.applicationSDLCSetupState.sdlcServerClient.setTracerService(
+      this.applicationStore.tracerService,
+    );
     this.depotServerClient.setTracerService(
       this.applicationStore.tracerService,
     );
@@ -101,26 +81,15 @@ export class LegendStudioBaseStore {
     this.initState.inProgress();
 
     // setup SDLC server client
-    yield flowResult(this.initializeSDLCServerClient());
-
-    let currentUserID = UNKNOWN_USER_ID;
-    try {
-      const currentUser = User.serialization.fromJson(
-        (yield this.sdlcServerClient.getCurrentUser()) as PlainObject<User>,
-      );
-      this.sdlcServerClient.setCurrentUser(currentUser);
-      currentUserID = currentUser.userId;
-    } catch (error) {
-      assertErrorThrown(error);
-      this.applicationStore.log.error(
-        LogEvent.create(LEGEND_STUDIO_APP_EVENT.SDLC_MANAGER_FAILURE),
-        error,
-      );
-      this.applicationStore.notifyWarning(error.message);
-    }
+    yield flowResult(
+      this.applicationSDLCSetupState.initializeSDLCServerClient(),
+    );
 
     // setup telemetry service
-    this.applicationStore.telemetryService.setUserId(currentUserID);
+    this.applicationStore.telemetryService.setUserId(
+      this.applicationSDLCSetupState.sdlcServerClient.currentUser?.userId ??
+        UNKNOWN_USER_ID,
+    );
 
     ApplicationTelemetry.logEvent_ApplicationInitialized(
       this.applicationStore.telemetryService,
@@ -140,100 +109,4 @@ export class LegendStudioBaseStore {
 
     this.initState.complete();
   }
-
-  private *initializeSDLCServerClient(): GeneratorFn<void> {
-    try {
-      this.isSDLCAuthorized =
-        (yield this.sdlcServerClient.isAuthorized()) as boolean;
-      if (!this.isSDLCAuthorized) {
-        this.applicationStore.navigator.jumpTo(
-          SDLCServerClient.authorizeCallbackUrl(
-            this.applicationStore.config.sdlcServerUrl,
-            this.applicationStore.navigator.getCurrentLocation(),
-          ),
-        );
-      } else {
-        // Only proceed intialization after passing authorization check
-
-        // check terms of service agreement status
-        this.SDLCServerTermsOfServicesUrlsToView =
-          (yield this.sdlcServerClient.hasAcceptedTermsOfService()) as string[];
-        if (this.SDLCServerTermsOfServicesUrlsToView.length) {
-          this.applicationStore.setActionAlertInfo({
-            message: `Please read and accept the SDLC servers' terms of service`,
-            prompt: `Click 'Done' when you have accepted all the terms`,
-            type: ActionAlertType.CAUTION,
-            actions: [
-              {
-                label: 'See terms of services',
-                default: true,
-                handler: (): void =>
-                  this.SDLCServerTermsOfServicesUrlsToView.forEach((url) =>
-                    this.applicationStore.navigator.openNewWindow(url),
-                  ),
-                type: ActionAlertActionType.PROCEED,
-              },
-              {
-                label: 'Done',
-                type: ActionAlertActionType.PROCEED_WITH_CAUTION,
-                handler: (): void => {
-                  this.dismissSDLCServerTermsOfServicesAlert();
-                  this.applicationStore.navigator.reload();
-                },
-              },
-            ],
-          });
-        }
-
-        // fetch server features config
-        yield this.sdlcServerClient.fetchServerFeaturesConfiguration();
-      }
-    } catch (error) {
-      assertErrorThrown(error);
-      if (
-        // eslint-disable-next-line no-process-env
-        process.env.NODE_ENV === 'development' &&
-        error instanceof NetworkClientError &&
-        error.response.status === HttpStatus.UNAUTHORIZED
-      ) {
-        this.applicationStore.setActionAlertInfo({
-          message:
-            'The first time the application starts in development mode, the developer would need to authenticate using SDLC server. Please do so then manually reload the app',
-          type: ActionAlertType.STANDARD,
-          actions: [
-            {
-              label: 'Authenticate using SDLC',
-              type: ActionAlertActionType.PROCEED,
-              default: true,
-              handler: (): void => {
-                this.applicationStore.navigator.openNewWindow(
-                  this.sdlcServerClient.currentUserUrl,
-                );
-                this.applicationStore.setBlockingAlert({
-                  message:
-                    'Waiting for the developer to authenticate using SDLC server',
-                  prompt:
-                    'Please manually reload the application after authentication',
-                });
-              },
-            },
-          ],
-        });
-      } else {
-        this.applicationStore.log.error(
-          LogEvent.create(LEGEND_STUDIO_APP_EVENT.SDLC_MANAGER_FAILURE),
-          error,
-        );
-        this.applicationStore.notifyError(error);
-      }
-    }
-  }
-
-  get needsToAcceptSDLCServerTermsOfServices(): boolean {
-    return Boolean(this.SDLCServerTermsOfServicesUrlsToView.length);
-  }
-
-  dismissSDLCServerTermsOfServicesAlert(): void {
-    this.SDLCServerTermsOfServicesUrlsToView = [];
-  }
 }

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