@finos/legend-application-studio 28.13.13 → 28.13.14

package/src/stores/editor/EditorStore.ts

@@ -110,6 +110,10 @@ import { SQLPlaygroundPanelState } from './panel-group/SQLPlaygroundPanelState.j
 import type { QuickInputState } from './QuickInputState.js';
 import { GlobalEndToEndWorkflowState } from './sidebar-state/end-to-end-workflow/GlobalEndToEndFlowState.js';
 import { openShowcaseManager } from '../ShowcaseManagerState.js';
+import {
+  GraphEditLazyGrammarModeState,
+  LazyTextEditorStore,
+} from '../lazy-text-editor/LazyTextEditorStore.js';
 
 export abstract class EditorExtensionState {
   /**
@@ -195,6 +199,8 @@ export class EditorStore implements CommandRegistrar {
   readonly tabManagerState = new EditorTabManagerState(this);
   supportedElementTypesWithCategory: Map<string, string[]>;
 
+  lazyTextEditorStore = new LazyTextEditorStore(this);
+
   constructor(
     applicationStore: LegendStudioApplicationStore,
     sdlcServerClient: SDLCServerClient,
@@ -211,6 +217,7 @@ export class EditorStore implements CommandRegistrar {
       graphEditorMode: observable,
       showSearchElementCommand: observable,
       quickInputState: observable,
+      lazyTextEditorStore: observable,
 
       isInViewerMode: computed,
       disableGraphEditing: computed,
@@ -230,6 +237,7 @@ export class EditorStore implements CommandRegistrar {
       initialize: flow,
       initMode: flow,
       initStandardMode: flow,
+      initializeLazyTextMode: flow,
       initConflictResolutionMode: flow,
       buildGraph: flow,
       toggleTextMode: flow,
@@ -715,6 +723,7 @@ export class EditorStore implements CommandRegistrar {
       ),
     ]);
     yield this.graphManagerState.initializeSystem();
+
     yield flowResult(this.initMode());
 
     onLeave(true);
@@ -728,6 +737,9 @@ export class EditorStore implements CommandRegistrar {
       case EDITOR_MODE.CONFLICT_RESOLUTION:
         yield flowResult(this.initConflictResolutionMode());
         return;
+      case EDITOR_MODE.LAZY_TEXT_EDITOR:
+        yield flowResult(this.initializeLazyTextMode());
+        return;
       default:
         throw new UnsupportedOperationError(
           `Can't initialize editor for unsupported mode '${this.mode}'`,
@@ -766,6 +778,92 @@ export class EditorStore implements CommandRegistrar {
     ]);
   }
 
+  *initializeLazyTextMode(): GeneratorFn<void> {
+    // set up
+    const projectId = this.sdlcState.activeProject.projectId;
+    const activeWorkspace = this.sdlcState.activeWorkspace;
+    const projectConfiguration = (yield this.sdlcServerClient.getConfiguration(
+      projectId,
+      activeWorkspace,
+    )) as PlainObject<ProjectConfiguration>;
+    this.projectConfigurationEditorState.setProjectConfiguration(
+      ProjectConfiguration.serialization.fromJson(projectConfiguration),
+    );
+    // make sure we set the original project configuration to a different object
+    this.projectConfigurationEditorState.setOriginalProjectConfiguration(
+      ProjectConfiguration.serialization.fromJson(projectConfiguration),
+    );
+
+    const startTime = Date.now();
+    let entities: Entity[];
+
+    this.initState.setMessage(`Fetching entities...`);
+    try {
+      entities = (yield this.sdlcServerClient.getEntities(
+        projectId,
+        activeWorkspace,
+      )) as Entity[];
+      this.changeDetectionState.workspaceLocalLatestRevisionState.setEntities(
+        entities,
+      );
+      this.applicationStore.logService.info(
+        LogEvent.create(GRAPH_MANAGER_EVENT.FETCH_GRAPH_ENTITIES__SUCCESS),
+        Date.now() - startTime,
+        'ms',
+      );
+    } catch {
+      return;
+    } finally {
+      this.initState.setMessage(undefined);
+    }
+    this.initState.setMessage('Building entities hash...');
+    yield flowResult(
+      this.changeDetectionState.workspaceLocalLatestRevisionState.buildEntityHashesIndex(
+        entities,
+        LogEvent.create(
+          LEGEND_STUDIO_APP_EVENT.CHANGE_DETECTION_BUILD_LOCAL_HASHES_INDEX__SUCCESS,
+        ),
+      ),
+    );
+
+    this.initState.setMessage('Building strict lazy graph...');
+    (yield flowResult(
+      this.graphState.buildGraphForLazyText(),
+    )) as GraphBuilderResult;
+    this.graphManagerState.graphBuildState.sync(ActionState.create().pass());
+    this.graphManagerState.generationsBuildState.sync(
+      ActionState.create().pass(),
+    );
+    this.initState.setMessage(undefined);
+    // switch to text mode
+    const graphEditorMode = new GraphEditLazyGrammarModeState(this);
+    try {
+      const editorGrammar =
+        (yield this.graphManagerState.graphManager.entitiesToPureCode(
+          this.changeDetectionState.workspaceLocalLatestRevisionState.entities,
+          { pretty: true },
+        )) as string;
+      yield flowResult(
+        graphEditorMode.grammarTextEditorState.setGraphGrammarText(
+          editorGrammar,
+        ),
+      );
+      this.graphEditorMode = graphEditorMode;
+      yield flowResult(
+        this.graphEditorMode.initialize({
+          useStoredEntities: true,
+        }),
+      );
+    } catch (error) {
+      assertErrorThrown(error);
+      this.applicationStore.notificationService.notifyWarning(
+        `Can't initialize strict text mode. Issue converting entities to grammar: ${error.message}`,
+      );
+      this.applicationStore.alertService.setBlockingAlert(undefined);
+      return;
+    }
+  }
+
   private *initConflictResolutionMode(): GeneratorFn<void> {
     yield flowResult(
       this.conflictResolutionState.initProjectConfigurationInConflictResolutionMode(),
@@ -946,11 +1044,15 @@ export class EditorStore implements CommandRegistrar {
     if (this.graphState.checkIfApplicationUpdateOperationIsRunning()) {
       return;
     }
-    this.applicationStore.alertService.setBlockingAlert({
-      message: 'Switching to text mode...',
-      showLoading: true,
-    });
+    if (this.graphEditorMode.disableLeaveMode) {
+      this.graphEditorMode.onLeave();
+      return;
+    }
     if (this.graphEditorMode instanceof GraphEditFormModeState) {
+      this.applicationStore.alertService.setBlockingAlert({
+        message: 'Switching to text mode...',
+        showLoading: true,
+      });
       yield flowResult(this.switchModes(GRAPH_EDITOR_MODE.GRAMMAR_TEXT));
     } else if (this.graphEditorMode instanceof GraphEditGrammarModeState) {
       yield flowResult(this.switchModes(GRAPH_EDITOR_MODE.FORM));
@@ -1136,6 +1238,7 @@ export class EditorStore implements CommandRegistrar {
     fallbackOptions?: {
       isCompilationFailure?: boolean;
       isGraphBuildFailure?: boolean;
+      useStoredEntities?: boolean;
     },
   ): GeneratorFn<void> {
     switch (to) {
@@ -1147,9 +1250,7 @@ export class EditorStore implements CommandRegistrar {
             graphEditorMode.cleanupBeforeEntering(fallbackOptions),
           );
           this.graphEditorMode = graphEditorMode;
-          yield flowResult(
-            this.graphEditorMode.initialize(Boolean(fallbackOptions)),
-          );
+          yield flowResult(this.graphEditorMode.initialize(fallbackOptions));
         } catch (error) {
           assertErrorThrown(error);
           this.applicationStore.notificationService.notifyWarning(

package/src/stores/editor/GraphEditGrammarModeState.ts

@@ -61,7 +61,15 @@ export class GraphEditGrammarModeState extends GraphEditorMode {
     this.grammarTextEditorState = new GrammarTextEditorState(this.editorStore);
   }
 
-  *initialize(isFallback?: boolean): GeneratorFn<void> {
+  get headerLabel(): string {
+    return 'Text Mode';
+  }
+
+  *initialize(isFallback?: {
+    isCompilationFailure?: boolean;
+    isGraphBuildFailure?: boolean;
+    useStoredEntities?: boolean;
+  }): GeneratorFn<void> {
     this.editorStore.localChangesState = new TextLocalChangesState(
       this.editorStore,
       this.editorStore.sdlcState,
@@ -93,7 +101,11 @@ export class GraphEditGrammarModeState extends GraphEditorMode {
         error,
       );
     }
-    if (isFallback) {
+    if (
+      isFallback?.isCompilationFailure ||
+      isFallback?.isGraphBuildFailure ||
+      isFallback?.useStoredEntities
+    ) {
       yield flowResult(
         this.globalCompile({
           ignoreBlocking: true,

package/src/stores/editor/GraphEditorMode.ts

@@ -42,7 +42,15 @@ export abstract class GraphEditorMode {
     this.editorStore = editorStore;
   }
 
-  abstract initialize(isFallback?: boolean): GeneratorFn<void>;
+  get disableLeaveMode(): boolean {
+    return false;
+  }
+
+  abstract initialize(options?: {
+    isCompilationFailure?: boolean;
+    isGraphBuildFailure?: boolean;
+    useStoredEntities?: boolean;
+  }): GeneratorFn<void>;
   abstract addElement(
     element: PackageableElement,
     packagePath: string | undefined,

package/src/stores/lazy-text-editor/LazyTextEditorStore.ts

@@ -0,0 +1,99 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { flow, flowResult, makeObservable } from 'mobx';
+import type { EditorStore } from '../editor/EditorStore.js';
+import { EDITOR_MODE } from '../editor/EditorConfig.js';
+import type { WorkspaceType } from '@finos/legend-server-sdlc';
+import type { GeneratorFn } from '@finos/legend-shared';
+import {
+  ActionAlertActionType,
+  ActionAlertType,
+} from '@finos/legend-application';
+import { generateEditorRoute } from '../../__lib__/LegendStudioNavigation.js';
+import { GraphEditGrammarModeState } from '../editor/GraphEditGrammarModeState.js';
+
+export class LazyTextEditorStore {
+  readonly editorStore: EditorStore;
+
+  constructor(editorStore: EditorStore) {
+    this.editorStore = editorStore;
+    makeObservable(this, {
+      init: flow,
+    });
+  }
+
+  *init(
+    projectId: string,
+    patchReleaseVersionId: string | undefined,
+    workspaceId: string,
+    workspaceType: WorkspaceType,
+  ): GeneratorFn<void> {
+    this.editorStore.setMode(EDITOR_MODE.LAZY_TEXT_EDITOR);
+    yield flowResult(
+      this.editorStore.initialize(
+        projectId,
+        patchReleaseVersionId,
+        workspaceId,
+        workspaceType,
+      ),
+    );
+  }
+}
+
+export class GraphEditLazyGrammarModeState extends GraphEditGrammarModeState {
+  override get disableLeaveMode(): boolean {
+    return true;
+  }
+
+  override get headerLabel(): string {
+    return 'Strict Text Mode (BETA)';
+  }
+
+  override *onLeave(): GeneratorFn<void> {
+    this.editorStore.applicationStore.alertService.setBlockingAlert(undefined);
+    this.editorStore.applicationStore.alertService.setActionAlertInfo({
+      message: `Form Mode Not Supported in Text Studio`,
+      prompt: `Text Studio only provides a light weight editor for editing studio projects to improve performance. If you want to do more actions, please open full edit mode`,
+      type: ActionAlertType.CAUTION,
+      actions: [
+        {
+          label: 'Open Studio Full Edit Mode',
+          type: ActionAlertActionType.PROCEED_WITH_CAUTION,
+          default: true,
+          handler: () => {
+            this.editorStore.applicationStore.navigationService.navigator.visitAddress(
+              this.editorStore.applicationStore.navigationService.navigator.generateAddress(
+                generateEditorRoute(
+                  this.editorStore.sdlcState.activeProject.projectId,
+                  this.editorStore.sdlcState.activePatch?.patchReleaseVersionId
+                    .id,
+                  this.editorStore.sdlcState.activeWorkspace.workspaceId,
+                  this.editorStore.sdlcState.activeWorkspace.workspaceType,
+                ),
+              ),
+            );
+          },
+        },
+        {
+          label: 'Cancel',
+          type: ActionAlertActionType.PROCEED,
+          default: true,
+        },
+      ],
+    });
+  }
+}

package/src/stores/showcase/ShowcaseViewerStore.ts

@@ -96,6 +96,12 @@ export class ShowcaseViewerStore {
       this._showcase = (yield this.client.getShowcase(
         showcasePath,
       )) as Showcase;
+      LegendStudioTelemetryHelper.logEvent_ShowcaseManagerShowcaseProjectLaunch(
+        this.editorStore.applicationStore.telemetryService,
+        {
+          showcasePath: showcasePath,
+        },
+      );
       // initialize graph manager
       yield this.editorStore.graphManagerState.graphManager.initialize(
         {

package/tsconfig.json

@@ -174,6 +174,7 @@
     "./src/stores/graph-modifier/STO_FlatData_GraphModifierHelper.ts",
     "./src/stores/graph-modifier/STO_Relational_GraphModifierHelper.ts",
     "./src/stores/graph-modifier/Testable_GraphModifierHelper.ts",
+    "./src/stores/lazy-text-editor/LazyTextEditorStore.ts",
     "./src/stores/project-view/ProjectViewerEditorMode.ts",
     "./src/stores/project-view/ProjectViewerStore.ts",
     "./src/stores/showcase/ShowcaseViewerEditorMode.ts",
@@ -296,6 +297,7 @@
     "./src/components/editor/side-bar/testable/GlobalTestRunner.tsx",
     "./src/components/extensions/Core_LegendStudioApplicationPlugin.tsx",
     "./src/components/extensions/DSL_ExternalFormat_LegendStudioApplicationPlugin.tsx",
+    "./src/components/lazy-text-editor/LazyTextEditor.tsx",
     "./src/components/project-view/ProjectViewer.tsx",
     "./src/components/project-view/ProjectViewerStoreProvider.tsx",
     "./src/components/showcase/ShowcaseViewer.tsx",