@finos/legend-application-studio 28.13.13 → 28.13.15

package/src/stores/ShowcaseManagerState.ts

@@ -22,7 +22,7 @@ import {
   guaranteeNonNullable,
   isNonNullable,
 } from '@finos/legend-shared';
-import { action, flow, makeObservable, observable } from 'mobx';
+import { action, computed, flow, makeObservable, observable } from 'mobx';
 import { LEGEND_STUDIO_APP_EVENT } from '../__lib__/LegendStudioEvent.js';
 import {
   type Showcase,
@@ -40,6 +40,7 @@ import {
 import type { TreeData, TreeNodeData } from '@finos/legend-art';
 import { DIRECTORY_PATH_DELIMITER } from '@finos/legend-graph';
 import { SHOWCASE_MANAGER_VIRTUAL_ASSISTANT_TAB_KEY } from '../components/extensions/Core_LegendStudioApplicationPlugin.js';
+import { LegendStudioTelemetryHelper } from '../__lib__/LegendStudioTelemetryHelper.js';
 
 export enum SHOWCASE_MANAGER_VIEW {
   EXPLORER = 'EXPLORER',
@@ -160,7 +161,7 @@ export class ShowcaseManagerState extends ApplicationExtensionState {
 
   private readonly showcaseServerClient?: ShowcaseRegistryServerClient;
 
-  showcases: ShowcaseMetadata[] = [];
+  allShowcases: ShowcaseMetadata[] | undefined;
   currentShowcase?: Showcase | undefined;
   showcaseLineToScroll?: number | undefined;
 
@@ -176,7 +177,7 @@ export class ShowcaseManagerState extends ApplicationExtensionState {
     super();
 
     makeObservable(this, {
-      showcases: observable,
+      allShowcases: observable,
       currentShowcase: observable,
       currentView: observable,
       explorerTreeData: observable.ref,
@@ -185,6 +186,8 @@ export class ShowcaseManagerState extends ApplicationExtensionState {
       showcaseSearchResults: observable.ref,
       currentSearchCaterogy: observable,
       showcaseLineToScroll: observable,
+      nonDevShowcases: computed,
+      logOpenManager: action,
       setCurrentView: action,
       closeShowcase: action,
       setExplorerTreeData: action,
@@ -209,6 +212,10 @@ export class ShowcaseManagerState extends ApplicationExtensionState {
     return ShowcaseManagerState.IDENTIFIER;
   }
 
+  get nonDevShowcases(): ShowcaseMetadata[] {
+    return this.allShowcases?.filter((showcase) => !showcase.development) ?? [];
+  }
+
   static retrieveNullableState(
     applicationStore: GenericLegendApplicationStore,
   ): ShowcaseManagerState | undefined {
@@ -263,9 +270,16 @@ export class ShowcaseManagerState extends ApplicationExtensionState {
     this.fetchShowcaseState.inProgress();
 
     try {
-      this.currentShowcase = (yield this.client.getShowcase(
+      const showcase = (yield this.client.getShowcase(
         metadata.path,
       )) as Showcase;
+      this.currentShowcase = showcase;
+      LegendStudioTelemetryHelper.logEvent_ShowcaseManagerShowcaseProjectLaunch(
+        this.applicationStore.telemetryService,
+        {
+          showcasePath: showcase.path,
+        },
+      );
       this.showcaseLineToScroll = showcaseLineToScroll;
       this.fetchShowcaseState.pass();
     } catch (error) {
@@ -278,6 +292,19 @@ export class ShowcaseManagerState extends ApplicationExtensionState {
     }
   }
 
+  logOpenManager(): void {
+    if (this.allShowcases) {
+      const report = {
+        showcasesTotalCount: this.allShowcases.length,
+        showcasesDevelopmentCount: this.nonDevShowcases.length,
+      };
+      LegendStudioTelemetryHelper.logEvent_ShowcaseManagerLaunch(
+        this.applicationStore.telemetryService,
+        report,
+      );
+    }
+  }
+
   closeShowcase(): void {
     this.currentShowcase = undefined;
     this.showcaseLineToScroll = undefined;
@@ -308,10 +335,11 @@ export class ShowcaseManagerState extends ApplicationExtensionState {
     this.initState.inProgress();
 
     try {
-      this.showcases = (
-        (yield this.client.getShowcases()) as ShowcaseMetadata[]
-      ).filter((showcase) => !showcase.development);
-      this.explorerTreeData = buildShowcasesExplorerTreeData(this.showcases);
+      this.allShowcases =
+        (yield this.client.getShowcases()) as ShowcaseMetadata[];
+      this.explorerTreeData = buildShowcasesExplorerTreeData(
+        this.nonDevShowcases,
+      );
       // expand all the root nodes by default
       this.explorerTreeData.rootIds.forEach((rootId) => {
         const rootNode = this.explorerTreeData?.nodes.get(rootId);
@@ -320,7 +348,6 @@ export class ShowcaseManagerState extends ApplicationExtensionState {
         }
       });
       this.setExplorerTreeData({ ...this.explorerTreeData });
-
       this.initState.pass();
     } catch (error) {
       assertErrorThrown(error);
@@ -347,7 +374,7 @@ export class ShowcaseManagerState extends ApplicationExtensionState {
       )) as ShowcaseTextSearchResult;
       this.textSearchResults = result.textMatches
         .map((match) => {
-          const matchingShowcase = this.showcases.find(
+          const matchingShowcase = this.nonDevShowcases.find(
             (showcase) => showcase.path === match.path,
           );
           if (matchingShowcase) {
@@ -361,7 +388,9 @@ export class ShowcaseManagerState extends ApplicationExtensionState {
         .filter(isNonNullable);
       this.showcaseSearchResults = result.showcases
         .map((showcasePath) =>
-          this.showcases.find((showcase) => showcase.path === showcasePath),
+          this.nonDevShowcases.find(
+            (showcase) => showcase.path === showcasePath,
+          ),
         )
         .filter(isNonNullable);
     } catch (error) {
@@ -388,5 +417,6 @@ export const openShowcaseManager = (
     applicationStore.assistantService.setSelectedTab(
       SHOWCASE_MANAGER_VIRTUAL_ASSISTANT_TAB_KEY,
     );
+    showcaseManagerState.logOpenManager();
   }
 };

package/src/stores/editor/EditorConfig.ts

@@ -19,6 +19,7 @@ export enum EDITOR_MODE {
   CONFLICT_RESOLUTION = 'CONFLICT_RESOLUTION',
   REVIEW = 'REVIEW',
   VIEWER = 'VIEWER',
+  LAZY_TEXT_EDITOR = 'LAZY_TEXT_EDITOR',
 }
 
 export enum TEST_RUNNER_TABS {

package/src/stores/editor/EditorGraphState.ts

@@ -491,6 +491,31 @@ export class EditorGraphState {
     }
   }
 
+  *buildGraphForLazyText(): GeneratorFn<void> {
+    this.isInitializingGraph = true;
+    const stopWatch = new StopWatch();
+    // reset
+    this.editorStore.graphManagerState.resetGraph();
+    // fetch and build dependencies
+    stopWatch.record();
+    const dependencyManager =
+      this.editorStore.graphManagerState.graphManager.createDependencyManager();
+    this.editorStore.graphManagerState.graph.dependencyManager =
+      dependencyManager;
+    this.editorStore.graphManagerState.dependenciesBuildState.setMessage(
+      `Fetching dependencies...`,
+    );
+    const dependencyEntitiesIndex = (yield flowResult(
+      this.getIndexedDependencyEntities(),
+    )) as Map<string, EntitiesWithOrigin>;
+    stopWatch.record(GRAPH_MANAGER_EVENT.FETCH_GRAPH_DEPENDENCIES__SUCCESS);
+    dependencyManager.initialize(dependencyEntitiesIndex);
+    this.isInitializingGraph = false;
+    this.editorStore.graphManagerState.dependenciesBuildState.sync(
+      ActionState.create().pass(),
+    );
+  }
+
   private redirectToModelImporterForDebugging(error: Error): void {
     if (this.editorStore.isInConflictResolutionMode) {
       this.editorStore.applicationStore.alertService.setBlockingAlert({

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,99 @@ 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 (error) {
+      assertErrorThrown(error);
+      this.applicationStore.logService.error(
+        LogEvent.create(GRAPH_MANAGER_EVENT.FETCH_GRAPH_ENTITIES_ERROR),
+        Date.now() - startTime,
+        'ms',
+      );
+      this.applicationStore.notificationService.notifyError(error);
+      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(),
@@ -830,7 +935,14 @@ export class EditorStore implements CommandRegistrar {
         Date.now() - startTime,
         'ms',
       );
-    } catch {
+    } catch (error) {
+      assertErrorThrown(error);
+      this.applicationStore.logService.error(
+        LogEvent.create(GRAPH_MANAGER_EVENT.FETCH_GRAPH_ENTITIES_ERROR),
+        Date.now() - startTime,
+        'ms',
+      );
+      this.applicationStore.notificationService.notifyError(error);
       return;
     } finally {
       this.initState.setMessage(undefined);
@@ -946,11 +1058,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 +1252,7 @@ export class EditorStore implements CommandRegistrar {
     fallbackOptions?: {
       isCompilationFailure?: boolean;
       isGraphBuildFailure?: boolean;
+      useStoredEntities?: boolean;
     },
   ): GeneratorFn<void> {
     switch (to) {
@@ -1147,9 +1264,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",