@finos/legend-application-studio 19.1.0 → 20.0.0

package/src/stores/EditorGraphState.ts

@@ -14,7 +14,14 @@
  * limitations under the License.
  */
 
-import { action, computed, flowResult, makeAutoObservable } from 'mobx';
+import {
+  action,
+  computed,
+  flow,
+  flowResult,
+  makeObservable,
+  observable,
+} from 'mobx';
 import { CHANGE_DETECTION_EVENT } from './ChangeDetectionEvent.js';
 import { GRAPH_EDITOR_MODE, AUX_PANEL_MODE } from './EditorConfig.js';
 import {
@@ -52,7 +59,6 @@ import {
   ProjectDependencyInfo,
 } from '@finos/legend-server-depot';
 import {
-  type PackageableElement,
   GRAPH_MANAGER_EVENT,
   CompilationError,
   EngineError,
@@ -78,9 +84,13 @@ import {
   DependencyGraphBuilderError,
   GraphDataDeserializationError,
   GraphBuilderError,
-  type GraphBuilderReport,
   GraphManagerTelemetry,
   DataElement,
+  type PackageableElement,
+  type GraphBuilderReport,
+  type CompilationWarning,
+  type TextCompilationResult,
+  type CompilationResult,
 } from '@finos/legend-graph';
 import {
   ActionAlertActionType,
@@ -94,7 +104,6 @@ import { graph_dispose } from './shared/modifier/GraphModifierHelper.js';
 import { PACKAGEABLE_ELEMENT_TYPE } from './shared/ModelClassifierUtils.js';
 import { GlobalTestRunnerState } from './sidebar-state/testable/GlobalTestRunnerState.js';
 import { LEGEND_STUDIO_APP_EVENT } from './LegendStudioAppEvent.js';
-import type { LambdaEditorState } from '@finos/legend-query-builder';
 
 export enum GraphBuilderStatus {
   SUCCEEDED = 'SUCCEEDED',
@@ -115,9 +124,12 @@ export interface GraphBuilderResult {
   error?: Error;
 }
 
+export type Problem = CompilationWarning | EngineError;
+
 export class EditorGraphState {
-  editorStore: EditorStore;
-  graphGenerationState: GraphGenerationState;
+  readonly editorStore: EditorStore;
+  readonly graphGenerationState: GraphGenerationState;
+
   isInitializingGraph = false;
   isRunningGlobalCompile = false;
   isRunningGlobalGenerate = false;
@@ -125,33 +137,64 @@ export class EditorGraphState {
   isUpdatingGraph = false; // critical synchronous update to refresh the graph
   isUpdatingApplication = false; // including graph update and async operations such as change detection
 
+  warnings: CompilationWarning[] = [];
+  error: EngineError | undefined;
+  private mostRecentTextModeCompilationGraphHash: string | undefined;
+  private mostRecentFormModeCompilationGraphHash: string | undefined;
+
+  enableStrictMode = false;
+
   constructor(editorStore: EditorStore) {
-    makeAutoObservable(this, {
-      editorStore: false,
-      graphGenerationState: false,
-      getPackageableElementType: false,
-      hasCompilationError: computed,
-      clearCompilationError: action,
+    makeObservable<
+      EditorGraphState,
+      | 'updateGraphAndApplication'
+      | 'mostRecentFormModeCompilationGraphHash'
+      | 'mostRecentTextModeCompilationGraphHash'
+    >(this, {
+      isInitializingGraph: observable,
+      isRunningGlobalCompile: observable,
+      isRunningGlobalGenerate: observable,
+      isApplicationLeavingTextMode: observable,
+      isUpdatingGraph: observable,
+      isUpdatingApplication: observable,
+      warnings: observable,
+      error: observable,
+      mostRecentFormModeCompilationGraphHash: observable,
+      mostRecentTextModeCompilationGraphHash: observable,
+      enableStrictMode: observable,
+      problems: computed,
+      areProblemsStale: computed,
+      isApplicationUpdateOperationIsRunning: computed,
+      clearProblems: action,
+      setEnableStrictMode: action,
+      buildGraph: flow,
+      loadEntityChangesToGraph: flow,
+      globalCompileInFormMode: flow,
+      globalCompileInTextMode: flow,
+      leaveTextMode: flow,
+      updateGraphAndApplication: flow,
+      updateGenerationGraphAndApplication: flow,
     });
 
     this.editorStore = editorStore;
     this.graphGenerationState = new GraphGenerationState(this.editorStore);
+    this.enableStrictMode =
+      editorStore.applicationStore.config.options.enableGraphBuilderStrictMode;
   }
 
-  get hasCompilationError(): boolean {
-    return (
-      Boolean(this.editorStore.grammarTextEditorState.error) ||
-      this.editorStore.openedEditorStates
-        .filter(filterByType(ElementEditorState))
-        .some((editorState) => editorState.hasCompilationError)
-    );
+  get problems(): Problem[] {
+    return [this.error, ...this.warnings].filter(isNonNullable);
   }
 
-  clearCompilationError(): void {
-    this.editorStore.grammarTextEditorState.setError(undefined);
-    this.editorStore.openedEditorStates
-      .filter(filterByType(ElementEditorState))
-      .forEach((editorState) => editorState.clearCompilationError());
+  get areProblemsStale(): boolean {
+    return (
+      (this.editorStore.isInFormMode &&
+        this.mostRecentFormModeCompilationGraphHash !==
+          this.editorStore.changeDetectionState.currentGraphHash) ||
+      (this.editorStore.isInGrammarTextMode &&
+        this.mostRecentTextModeCompilationGraphHash !==
+          this.editorStore.grammarTextEditorState.currentTextGraphHash)
+    );
   }
 
   get isApplicationUpdateOperationIsRunning(): boolean {
@@ -198,6 +241,64 @@ export class EditorGraphState {
     return false;
   }
 
+  /**
+   * Get entitiy changes to prepare for syncing
+   */
+  computeLocalEntityChanges(): EntityChange[] {
+    const baseHashesIndex = this.editorStore.isInConflictResolutionMode
+      ? this.editorStore.changeDetectionState
+          .conflictResolutionHeadRevisionState.entityHashesIndex
+      : this.editorStore.changeDetectionState.workspaceLocalLatestRevisionState
+          .entityHashesIndex;
+    const originalPaths = new Set(Array.from(baseHashesIndex.keys()));
+    const entityChanges: EntityChange[] = [];
+    this.editorStore.graphManagerState.graph.allOwnElements.forEach(
+      (element) => {
+        const elementPath = element.path;
+        if (baseHashesIndex.get(elementPath) !== element.hashCode) {
+          const entity =
+            this.editorStore.graphManagerState.graphManager.elementToEntity(
+              element,
+              {
+                pruneSourceInformation: true,
+              },
+            );
+          entityChanges.push({
+            classifierPath: entity.classifierPath,
+            entityPath: element.path,
+            content: entity.content,
+            type:
+              baseHashesIndex.get(elementPath) !== undefined
+                ? EntityChangeType.MODIFY
+                : EntityChangeType.CREATE,
+          });
+        }
+        originalPaths.delete(elementPath);
+      },
+    );
+    Array.from(originalPaths).forEach((path) => {
+      entityChanges.push({
+        type: EntityChangeType.DELETE,
+        entityPath: path,
+      });
+    });
+    return entityChanges;
+  }
+
+  clearProblems(): void {
+    this.error = undefined;
+    this.editorStore.openedEditorStates
+      .filter(filterByType(ElementEditorState))
+      .forEach((editorState) => editorState.clearCompilationError());
+    this.mostRecentFormModeCompilationGraphHash = undefined;
+    this.mostRecentTextModeCompilationGraphHash = undefined;
+    this.warnings = [];
+  }
+
+  setEnableStrictMode(val: boolean): void {
+    this.enableStrictMode = val;
+  }
+
   *buildGraph(entities: Entity[]): GeneratorFn<GraphBuilderResult> {
     try {
       this.isInitializingGraph = true;
@@ -242,6 +343,7 @@ export class EditorGraphState {
             TEMPORARY__preserveSectionIndex:
               this.editorStore.applicationStore.config.options
                 .TEMPORARY__preserveSectionIndex,
+            strict: this.enableStrictMode,
           },
         )) as GraphBuilderReport;
 
@@ -380,50 +482,6 @@ export class EditorGraphState {
     this.editorStore.openState(this.editorStore.modelImporterState);
   }
 
-  /**
-   * Get entitiy changes to prepare for syncing
-   */
-  computeLocalEntityChanges(): EntityChange[] {
-    const baseHashesIndex = this.editorStore.isInConflictResolutionMode
-      ? this.editorStore.changeDetectionState
-          .conflictResolutionHeadRevisionState.entityHashesIndex
-      : this.editorStore.changeDetectionState.workspaceLocalLatestRevisionState
-          .entityHashesIndex;
-    const originalPaths = new Set(Array.from(baseHashesIndex.keys()));
-    const entityChanges: EntityChange[] = [];
-    this.editorStore.graphManagerState.graph.allOwnElements.forEach(
-      (element) => {
-        const elementPath = element.path;
-        if (baseHashesIndex.get(elementPath) !== element.hashCode) {
-          const entity =
-            this.editorStore.graphManagerState.graphManager.elementToEntity(
-              element,
-              {
-                pruneSourceInformation: true,
-              },
-            );
-          entityChanges.push({
-            classifierPath: entity.classifierPath,
-            entityPath: element.path,
-            content: entity.content,
-            type:
-              baseHashesIndex.get(elementPath) !== undefined
-                ? EntityChangeType.MODIFY
-                : EntityChangeType.CREATE,
-          });
-        }
-        originalPaths.delete(elementPath);
-      },
-    );
-    Array.from(originalPaths).forEach((path) => {
-      entityChanges.push({
-        type: EntityChangeType.DELETE,
-        entityPath: path,
-      });
-    });
-    return entityChanges;
-  }
-
   /**
    * Loads entity changes to graph and updates application.
    */
@@ -454,8 +512,8 @@ export class EditorGraphState {
   }
 
   // TODO: when we support showing multiple notifications, we can take this options out as the only users of this
-  // is delete element flow, where we want to say `re-compiling graph after deletion`, but because compilation
-  // sometimes is so fast, the message flashes, so we want to combine with the message in this method
+  // is delete element flow, where we want to say `re-compiling graph after deletion`, but because sometimes, compilation
+  // is so fast, the message flashes, so we want to combine with the message in this method
   *globalCompileInFormMode(options?: {
     message?: string;
     disableNotificationOnSuccess?: boolean;
@@ -465,30 +523,50 @@ export class EditorGraphState {
       this.editorStore.isInFormMode,
       'Editor must be in form mode to call this method',
     );
+
     if (this.checkIfApplicationUpdateOperationIsRunning()) {
       return FormModeCompilationOutcome.SKIPPED;
     }
-    this.isRunningGlobalCompile = true;
+
+    const currentGraphHash =
+      this.editorStore.changeDetectionState.currentGraphHash;
+
     try {
-      this.clearCompilationError();
+      this.isRunningGlobalCompile = true;
+      this.clearProblems();
       if (options?.openConsole) {
         this.editorStore.setActiveAuxPanelMode(AUX_PANEL_MODE.CONSOLE);
       }
+
       // NOTE: here we always keep the source information while compiling in form mode
       // so that the form parts where the user interacted with (i.e. where the lamdbas source
       // information are populated), can reveal compilation error. If compilation errors
       // show up in other parts, the user will get redirected to text-mode
-      yield this.editorStore.graphManagerState.graphManager.compileGraph(
-        this.editorStore.graphManagerState.graph,
-        {
-          keepSourceInformation: true,
-        },
-      );
+      const compilationResult =
+        (yield this.editorStore.graphManagerState.graphManager.compileGraph(
+          this.editorStore.graphManagerState.graph,
+          {
+            keepSourceInformation: true,
+          },
+        )) as CompilationResult;
+
+      this.warnings = compilationResult.warnings ?? [];
+      this.mostRecentFormModeCompilationGraphHash = currentGraphHash;
+
       if (!options?.disableNotificationOnSuccess) {
-        this.editorStore.applicationStore.notifySuccess(
-          'Compiled successfully',
-        );
+        if (this.warnings.length) {
+          this.editorStore.applicationStore.notifyWarning(
+            `Compilation suceeded with warnings`,
+          );
+        } else {
+          if (!options?.disableNotificationOnSuccess) {
+            this.editorStore.applicationStore.notifySuccess(
+              'Compiled successfully',
+            );
+          }
+        }
       }
+
       return FormModeCompilationOutcome.SUCCEEDED;
     } catch (error) {
       assertErrorThrown(error);
@@ -499,6 +577,7 @@ export class EditorGraphState {
         LogEvent.create(GRAPH_MANAGER_EVENT.COMPILATION_FAILURE),
         error,
       );
+      this.mostRecentFormModeCompilationGraphHash = currentGraphHash;
       let fallbackToTextModeForDebugging = true;
       // if compilation failed, we try to reveal the error in form mode,
       // if even this fail, we will fall back to show it in text mode
@@ -560,6 +639,7 @@ export class EditorGraphState {
         );
         return FormModeCompilationOutcome.FAILED_AND_FALLBACK_TO_TEXT_MODE;
       } else {
+        this.error = error;
         this.editorStore.applicationStore.notifyWarning(
           `Compilation failed: ${error.message}`,
         );
@@ -582,41 +662,61 @@ export class EditorGraphState {
       this.editorStore.isInGrammarTextMode,
       'Editor must be in text mode to call this method',
     );
+
     if (
       !options?.ignoreBlocking &&
       this.checkIfApplicationUpdateOperationIsRunning()
     ) {
       return;
     }
+
+    const currentGraphHash =
+      this.editorStore.grammarTextEditorState.currentTextGraphHash;
+
     try {
       this.isRunningGlobalCompile = true;
-      this.clearCompilationError();
+      this.clearProblems();
       if (options?.openConsole) {
         this.editorStore.setActiveAuxPanelMode(AUX_PANEL_MODE.CONSOLE);
       }
-      const entities =
+
+      const compilationResult =
         (yield this.editorStore.graphManagerState.graphManager.compileText(
           this.editorStore.grammarTextEditorState.graphGrammarText,
           this.editorStore.graphManagerState.graph,
-        )) as Entity[];
+        )) as TextCompilationResult;
+
+      const entities = compilationResult.entities;
+      this.mostRecentTextModeCompilationGraphHash = currentGraphHash;
+      this.warnings = compilationResult.warnings ?? [];
 
       if (!options?.disableNotificationOnSuccess) {
-        this.editorStore.applicationStore.notifySuccess(
-          'Compiled successfully',
-        );
+        if (this.warnings.length) {
+          this.editorStore.applicationStore.notifyWarning(
+            `Compilation suceeded with warnings`,
+          );
+        } else {
+          if (!options?.disableNotificationOnSuccess) {
+            this.editorStore.applicationStore.notifySuccess(
+              'Compiled successfully',
+            );
+          }
+        }
       }
 
       yield flowResult(this.updateGraphAndApplication(entities));
     } catch (error) {
       assertErrorThrown(error);
+      this.mostRecentTextModeCompilationGraphHash = currentGraphHash;
       if (error instanceof EngineError) {
-        this.editorStore.grammarTextEditorState.setError(error);
+        this.error = error;
+        if (error.sourceInformation) {
+          this.editorStore.grammarTextEditorState.setForcedCursorPosition({
+            lineNumber: error.sourceInformation.startLine,
+            column: error.sourceInformation.startColumn,
+          });
+        }
       }
-      this.editorStore.applicationStore.log.error(
-        LogEvent.create(GRAPH_MANAGER_EVENT.COMPILATION_FAILURE),
-        'Compilation failed:',
-        error,
-      );
       if (
         !this.editorStore.applicationStore.notification ||
         !options?.suppressCompilationFailureMessage
@@ -640,13 +740,13 @@ export class EditorGraphState {
     }
     try {
       this.isApplicationLeavingTextMode = true;
-      this.clearCompilationError();
+      this.clearProblems();
       this.editorStore.applicationStore.setBlockingAlert({
         message: 'Compiling graph before leaving text mode...',
         showLoading: true,
       });
       try {
-        const entities =
+        const compilationResult =
           (yield this.editorStore.graphManagerState.graphManager.compileText(
             this.editorStore.grammarTextEditorState.graphGrammarText,
             this.editorStore.graphManagerState.graph,
@@ -657,12 +757,18 @@ export class EditorGraphState {
               onError: () =>
                 this.editorStore.applicationStore.setBlockingAlert(undefined),
             },
-          )) as Entity[];
+          )) as TextCompilationResult;
+
+        this.warnings = compilationResult.warnings ?? [];
         this.editorStore.applicationStore.setBlockingAlert({
           message: 'Leaving text mode and rebuilding graph...',
           showLoading: true,
         });
-        yield flowResult(this.updateGraphAndApplication(entities));
+        yield flowResult(
+          this.updateGraphAndApplication(compilationResult.entities),
+        );
+        this.mostRecentFormModeCompilationGraphHash =
+          this.editorStore.changeDetectionState.getCurrentGraphHash();
         this.editorStore.grammarTextEditorState.setGraphGrammarText('');
         this.editorStore.grammarTextEditorState.resetCurrentElementLabelRegexString();
         this.editorStore.setGraphEditMode(GRAPH_EDITOR_MODE.FORM);
@@ -671,8 +777,13 @@ export class EditorGraphState {
         }
       } catch (error) {
         assertErrorThrown(error);
-        if (error instanceof EngineError) {
-          this.editorStore.grammarTextEditorState.setError(error);
+        this.mostRecentFormModeCompilationGraphHash =
+          this.editorStore.changeDetectionState.getCurrentGraphHash();
+        if (error instanceof EngineError && error.sourceInformation) {
+          this.editorStore.grammarTextEditorState.setForcedCursorPosition({
+            lineNumber: error.sourceInformation.startLine,
+            column: error.sourceInformation.startColumn,
+          });
         }
         this.editorStore.applicationStore.log.error(
           LogEvent.create(GRAPH_MANAGER_EVENT.COMPILATION_FAILURE),
@@ -721,30 +832,6 @@ export class EditorGraphState {
     }
   }
 
-  /**
-   * This function is used in lambda editor in form mode when user try to do an action that involves the lambda being edited, it takes an action
-   * and proceeds with a parsing check for the current lambda before executing the action. This prevents case where user quickly type something
-   * that does not parse and hit compile or generate right away.
-   */
-  *checkLambdaParsingError(
-    lambdaHolderElement: LambdaEditorState,
-    checkParsingError: boolean,
-    onSuccess: () => Promise<void>,
-  ): GeneratorFn<void> {
-    this.clearCompilationError();
-    lambdaHolderElement.clearErrors();
-    if (checkParsingError) {
-      yield flowResult(
-        lambdaHolderElement.convertLambdaGrammarStringToObject(),
-      );
-      // abort action if parser error occurred
-      if (lambdaHolderElement.parserError) {
-        return;
-      }
-    }
-    yield onSuccess();
-  }
-
   /**
    * NOTE: IMPORTANT! This method is both a savior and a sinner. It helps reprocessing the graph state to use a new graph
    * built from the new model context data, it resets the graph properly. The bane here is that resetting the graph properly is
@@ -856,6 +943,7 @@ export class EditorGraphState {
           TEMPORARY__preserveSectionIndex:
             this.editorStore.applicationStore.config.options
               .TEMPORARY__preserveSectionIndex,
+          strict: this.enableStrictMode,
         },
       );
 
@@ -1023,28 +1111,27 @@ export class EditorGraphState {
     }
   }
 
-  *getIndexedDependencyEntities(): GeneratorFn<Map<string, Entity[]>> {
+  async getIndexedDependencyEntities(): Promise<Map<string, Entity[]>> {
     const dependencyEntitiesIndex = new Map<string, Entity[]>();
     const currentConfiguration =
       this.editorStore.projectConfigurationEditorState
         .currentProjectConfiguration;
     try {
       if (currentConfiguration.projectDependencies.length) {
-        const dependencyCoordinates = (yield flowResult(
-          this.buildProjectDependencyCoordinates(
+        const dependencyCoordinates =
+          await this.buildProjectDependencyCoordinates(
             currentConfiguration.projectDependencies,
-          ),
-        )) as ProjectDependencyCoordinates[];
+          );
         // NOTE: if A@v1 is transitive dependencies of 2 or more
         // direct dependencies, metadata server will take care of deduplication
         const dependencyEntitiesJson =
-          (yield this.editorStore.depotServerClient.collectDependencyEntities(
+          await this.editorStore.depotServerClient.collectDependencyEntities(
             dependencyCoordinates.map((e) =>
               ProjectDependencyCoordinates.serialization.toJson(e),
             ),
             true,
             true,
-          )) as PlainObject<ProjectVersionEntities>[];
+          );
         const dependencyEntities = dependencyEntitiesJson.map((e) =>
           ProjectVersionEntities.serialization.fromJson(e),
         );
@@ -1080,11 +1167,11 @@ export class EditorGraphState {
           let dependencyInfo: ProjectDependencyInfo | undefined;
           try {
             const dependencyTree =
-              (yield this.editorStore.depotServerClient.analyzeDependencyTree(
+              await this.editorStore.depotServerClient.analyzeDependencyTree(
                 dependencyCoordinates.map((e) =>
                   ProjectDependencyCoordinates.serialization.toJson(e),
                 ),
-              )) as PlainObject<ProjectVersionEntities>;
+              );
             dependencyInfo =
               ProjectDependencyInfo.serialization.fromJson(dependencyTree);
           } catch (error) {
@@ -1130,10 +1217,10 @@ export class EditorGraphState {
     return dependencyEntitiesIndex;
   }
 
-  *buildProjectDependencyCoordinates(
+  async buildProjectDependencyCoordinates(
     projectDependencies: ProjectDependency[],
-  ): GeneratorFn<ProjectDependencyCoordinates[]> {
-    return (yield Promise.all(
+  ): Promise<ProjectDependencyCoordinates[]> {
+    return Promise.all(
       projectDependencies.map((dep) => {
         // legacyDependencies
         // We do this for backward compatible reasons as we expect current dependency ids to be in the format of {groupId}:{artifactId}.
@@ -1178,7 +1265,7 @@ export class EditorGraphState {
           );
         }
       }),
-    )) as ProjectDependencyCoordinates[];
+    );
   }
 
   // -------------------------------------------------- UTILITIES -----------------------------------------------------