@finos/legend-application-studio 28.19.56 → 28.19.57

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@finos/legend-application-studio",
-  "version": "28.19.56",
+  "version": "28.19.57",
   "description": "Legend Studio application core",
   "keywords": [
     "legend",
@@ -45,14 +45,14 @@
     "test:watch": "jest --watch"
   },
   "dependencies": {
-    "@finos/legend-application": "16.0.76",
-    "@finos/legend-art": "7.1.127",
+    "@finos/legend-application": "16.0.77",
+    "@finos/legend-art": "7.1.128",
     "@finos/legend-code-editor": "2.0.128",
-    "@finos/legend-data-cube": "0.3.38",
-    "@finos/legend-extension-dsl-data-product": "0.0.16",
+    "@finos/legend-data-cube": "0.3.39",
+    "@finos/legend-extension-dsl-data-product": "0.0.17",
     "@finos/legend-graph": "32.3.9",
-    "@finos/legend-lego": "2.0.139",
-    "@finos/legend-query-builder": "4.17.51",
+    "@finos/legend-lego": "2.0.140",
+    "@finos/legend-query-builder": "4.17.52",
     "@finos/legend-server-depot": "6.1.1",
     "@finos/legend-server-lakehouse": "0.3.9",
     "@finos/legend-server-sdlc": "5.3.65",

package/src/components/editor/editor-group/dataProduct/DataProductEditor.tsx

@@ -79,6 +79,7 @@ import {
   PURE_MappingIcon,
   GitBranchIcon,
   ListIcon,
+  PanelLoadingIndicator,
 } from '@finos/legend-art';
 import {
   type ChangeEventHandler,
@@ -104,9 +105,6 @@ import {
   type Mapping,
   type PackageableElement,
   type PackageableRuntime,
-  type V1_AccessPointGroupInfo,
-  type V1_AccessPointImplementation,
-  type V1_DataProductArtifact,
   DataProductEmbeddedImageIcon,
   DataProductLibraryIcon,
   Email,
@@ -400,12 +398,12 @@ const AccessPointGenerationViewer = observer(
     const { accessPointState, generationOutput } = props;
     const editorStore = accessPointState.state.state.editorStore;
     const closeDebug = (): void => {
-      accessPointState.setShowDebug(false);
+      accessPointState.setArtifactContent(undefined);
     };
 
     return (
       <Dialog
-        open={accessPointState.showDebug}
+        open={accessPointState.artifactGenerationContent !== undefined}
         onClose={closeDebug}
         classes={{
           root: 'editor-modal__root-container',
@@ -466,7 +464,6 @@ export const LakehouseDataProductAccessPointEditor = observer(
     const [editingTitle, setEditingTitle] = useState(false);
     const [isHoveringTitle, setIsHoveringTitle] = useState(false);
     const ref = useRef<HTMLDivElement>(null);
-    const [debugOutput, setDebugOutput] = useState('');
 
     const handleDescriptionEdit = () => setEditingDescription(true);
     const handleDescriptionBlur = () => {
@@ -500,49 +497,10 @@ export const LakehouseDataProductAccessPointEditor = observer(
       },
     );
 
-    const debugPlanGeneration = async (): Promise<void> => {
-      try {
-        const generatedArtifacts =
-          await editorStore.graphManagerState.graphManager.generateArtifacts(
-            editorStore.graphManagerState.graph,
-            editorStore.graphEditorMode.getGraphTextInputOption(),
-            [groupState.state.elementPath],
-          );
-        const dataProductExtension = 'dataProduct';
-        const dataProductArtifact = generatedArtifacts.values.filter(
-          (artifact) => artifact.extension === dataProductExtension,
-        );
-        const dataProductContent =
-          dataProductArtifact[0]?.artifactsByExtensionElements[0]?.files[0]
-            ?.content ?? null;
-
-        if (dataProductContent) {
-          const contentJson = JSON.parse(
-            dataProductContent,
-          ) as V1_DataProductArtifact;
-          const apPlanGeneration = contentJson.accessPointGroups
-            .find(
-              (group: V1_AccessPointGroupInfo) =>
-                group.id === groupState.value.id,
-            )
-            ?.accessPointImplementations.find(
-              (apImplementation: V1_AccessPointImplementation) =>
-                apImplementation.id === accessPoint.id,
-            );
-
-          setDebugOutput(JSON.stringify(apPlanGeneration, null, 2));
-          accessPointState.setShowDebug(true);
-        } else {
-          throw new Error(
-            'Could not find contents of this data product artifact',
-          );
-        }
-      } catch (error) {
-        editorStore.applicationStore.notificationService.notifyError(
-          `Failed to fetch access point plan generation: ${error}`,
-        );
-      }
-    };
+    const debugPlanGeneration =
+      editorStore.applicationStore.guardUnhandledError(() =>
+        flowResult(accessPointState.generateArtifact()),
+      );
 
     const handleRemoveAccessPoint = (): void => {
       editorStore.applicationStore.alertService.setActionAlertInfo({
@@ -718,11 +676,7 @@ export const LakehouseDataProductAccessPointEditor = observer(
                     <MenuContent>
                       <MenuContentItem
                         className="btn__dropdown-combo__option"
-                        onClick={() => {
-                          debugPlanGeneration().catch(
-                            editorStore.applicationStore.alertUnhandledError,
-                          );
-                        }}
+                        onClick={debugPlanGeneration}
                       >
                         <div
                           style={{
@@ -896,10 +850,10 @@ export const LakehouseDataProductAccessPointEditor = observer(
           >
             <TimesIcon />
           </button>
-          {accessPointState.showDebug && (
+          {accessPointState.artifactGenerationContent && (
             <AccessPointGenerationViewer
               accessPointState={accessPointState}
-              generationOutput={debugOutput}
+              generationOutput={accessPointState.artifactGenerationContent}
             />
           )}
         </div>
@@ -1401,6 +1355,7 @@ const AccessPointGroupEditor = observer(
         className="access-point-editor__group-container"
         data-testid={LEGEND_STUDIO_TEST_ID.ACCESS_POINT_GROUP_EDITOR}
       >
+        <PanelLoadingIndicator isLoading={groupState.isRunningProcess} />
         <div className="access-point-editor__group-container__name-editor">
           {editingName ? (
             <textarea

package/src/components/project-view/ProjectViewer.tsx

@@ -42,8 +42,9 @@ import {
   HammerIcon,
   TerminalIcon,
   ResizablePanelSplitterLine,
+  GitlabIcon,
 } from '@finos/legend-art';
-import { isNonNullable } from '@finos/legend-shared';
+import { assertErrorThrown, isNonNullable } from '@finos/legend-shared';
 import {
   useProjectViewerStore,
   withProjectViewerStore,
@@ -51,6 +52,7 @@ import {
 import {
   type ProjectViewerPathParams,
   generateSetupRoute,
+  generateViewProjectRoute,
 } from '../../__lib__/LegendStudioNavigation.js';
 import { ProjectSearchCommand } from '../editor/command-center/ProjectSearchCommand.js';
 import { flowResult } from 'mobx';
@@ -71,6 +73,9 @@ import { EmbeddedQueryBuilder } from '../editor/EmbeddedQueryBuilder.js';
 import type { ActivityBarItemConfig } from '@finos/legend-lego/application';
 import { ActivityBarMenu } from '../editor/ActivityBar.js';
 import { PanelGroup } from '../editor/panel-group/PanelGroup.js';
+import { StoreProjectData } from '@finos/legend-server-depot';
+import { generateGAVCoordinates } from '@finos/legend-storage';
+import { Project } from '@finos/legend-server-sdlc';
 
 const ProjectViewerStatusBar = observer(() => {
   const params = useParams<ProjectViewerPathParams>();
@@ -82,6 +87,7 @@ const ProjectViewerStatusBar = observer(() => {
   const extraSDLCInfo = params.revisionId ?? params.versionId ?? 'HEAD';
   const projectId = params.projectId;
   const currentProject = editorStore.sdlcState.currentProject;
+  const gav = viewerStore.projectGAVCoordinates;
   const versionBehindProjectHead =
     viewerStore.currentRevision &&
     viewerStore.version &&
@@ -117,6 +123,54 @@ const ProjectViewerStatusBar = observer(() => {
     applicationStore.assistantService.toggleAssistant();
   const togglePanel = (): void => editorStore.panelGroupDisplayState.toggle();
 
+  const visitProject = async (): Promise<void> => {
+    try {
+      if (gav) {
+        const project = StoreProjectData.serialization.fromJson(
+          await editorStore.depotServerClient.getProject(
+            gav.groupId,
+            gav.artifactId,
+          ),
+        );
+        const sdlcProjectUrl = generateViewProjectRoute(project.projectId);
+        applicationStore.navigationService.navigator.visitAddress(
+          applicationStore.navigationService.navigator.generateAddress(
+            sdlcProjectUrl,
+          ),
+        );
+      }
+    } catch (error) {
+      assertErrorThrown(error);
+      editorStore.applicationStore.notificationService.notifyError(
+        `Can't open project.`,
+      );
+    }
+  };
+
+  const visitWebProjectUrl = async (): Promise<void> => {
+    try {
+      if (gav) {
+        const project = StoreProjectData.serialization.fromJson(
+          await editorStore.depotServerClient.getProject(
+            gav.groupId,
+            gav.artifactId,
+          ),
+        );
+        const sdlcProject = Project.serialization.fromJson(
+          await editorStore.sdlcServerClient.getProject(project.projectId),
+        );
+        applicationStore.navigationService.navigator.visitAddress(
+          sdlcProject.webUrl,
+        );
+      }
+    } catch (error) {
+      assertErrorThrown(error);
+      editorStore.applicationStore.notificationService.notifyError(
+        `Can't open project.`,
+      );
+    }
+  };
+
   return (
     <div
       data-testid={LEGEND_STUDIO_TEST_ID.STATUS_BAR}
@@ -155,6 +209,36 @@ const ProjectViewerStatusBar = observer(() => {
             )}
           </div>
         )}
+        {!currentProject && gav && (
+          <div className="editor__status-bar__workspace">
+            <div className="editor__status-bar__workspace__icon">
+              <CodeBranchIcon />
+            </div>
+            <div className="editor__status-bar__workspace__project">
+              <button
+                className="editor__status-bar__workspace__project"
+                title="Go to Studio SDLC View of Project"
+                tabIndex={-1}
+                onClick={() => flowResult(visitProject())}
+              >
+                {`${generateGAVCoordinates(gav.groupId, gav.artifactId, undefined)}`}
+              </button>
+            </div>
+            /<div></div>
+            <div
+              onClick={() => flowResult(visitWebProjectUrl())}
+              className="editor__status-bar__workspace__workspace"
+            >
+              {gav.versionId}
+            </div>
+            <button
+              onClick={() => flowResult(visitWebProjectUrl())}
+              className="editor__status-bar__workspace__icon"
+            >
+              <GitlabIcon />
+            </button>
+          </div>
+        )}
       </div>
       <div className="editor__status-bar__right">
         <button

package/src/stores/editor/editor-state/element-editor-state/dataProduct/DataProductEditorState.ts

@@ -48,6 +48,10 @@ import {
   DataProductElementScope,
   validate_PureExecutionMapping,
   type V1_RawLineageModel,
+  type ArtifactGenerationExtensionResult,
+  type V1_DataProductArtifact,
+  type V1_AccessPointGroupInfo,
+  type V1_AccessPointImplementation,
 } from '@finos/legend-graph';
 import type { EditorStore } from '../../../EditorStore.js';
 import { ElementEditorState } from '../ElementEditorState.js';
@@ -129,6 +133,10 @@ export class AccessPointState {
     });
   }
 
+  get isRunningProcess(): boolean {
+    return false;
+  }
+
   changeGroupState(newGroup: AccessPointGroupState): void {
     this.state = newGroup;
   }
@@ -243,22 +251,23 @@ export class AccessPointLambdaEditorState extends LambdaEditorState {
 export class LakehouseAccessPointState extends AccessPointState {
   declare accessPoint: LakehouseAccessPoint;
   lambdaState: AccessPointLambdaEditorState;
-
-  showDebug = false;
-
+  artifactGenerationContent: string | undefined;
+  generatingArtifactState = ActionState.create();
   // Add lineage state and isGeneratingLineage
   lineageState: LineageState;
-  isGeneratingLineage = false;
+  generatingLineageAction = ActionState.create();
 
   constructor(val: LakehouseAccessPoint, editorState: AccessPointGroupState) {
     super(val, editorState);
     makeObservable(this, {
       lambdaState: observable,
-      showDebug: observable,
-      setShowDebug: action,
-      // Add observables for lineage
+      artifactGenerationContent: observable,
+      generatingArtifactState: observable,
+      generateArtifact: flow,
+      isRunningProcess: computed,
       lineageState: observable,
-      isGeneratingLineage: observable,
+      setArtifactContent: action,
+      generatingLineageAction: observable,
       generateLineage: flow,
     });
     this.accessPoint = val;
@@ -268,43 +277,102 @@ export class LakehouseAccessPointState extends AccessPointState {
     );
   }
 
-  setShowDebug(value: boolean): void {
-    this.showDebug = value;
+  get editorStore(): EditorStore {
+    return this.state.state.editorStore;
+  }
+
+  override get isRunningProcess(): boolean {
+    return (
+      this.generatingArtifactState.isInProgress ||
+      this.generatingLineageAction.isInProgress
+    );
+  }
+
+  setArtifactContent(val: string | undefined): void {
+    this.artifactGenerationContent = val;
   }
 
   *generateLineage(): GeneratorFn<void> {
-    if (this.isGeneratingLineage) {
+    if (this.generatingLineageAction.isInProgress) {
       return;
     }
     try {
-      this.isGeneratingLineage = true;
+      this.generatingLineageAction.inProgress();
       const lambda = this.accessPoint.func;
       const lineageRawData =
-        (yield this.state.state.editorStore.graphManagerState.graphManager.generateLineage(
+        (yield this.editorStore.graphManagerState.graphManager.generateLineage(
           lambda,
           undefined,
           undefined,
-          this.state.state.editorStore.graphManagerState.graph,
+          this.editorStore.graphManagerState.graph,
           undefined,
         )) as V1_RawLineageModel;
 
       const lineageData =
-        this.state.state.editorStore.graphManagerState.graphManager.buildLineage(
+        this.editorStore.graphManagerState.graphManager.buildLineage(
           lineageRawData,
         );
 
       this.lineageState.setLineageData(lineageData);
+      this.generatingLineageAction.complete();
     } catch (error) {
       assertErrorThrown(error);
-      this.state.state.editorStore.applicationStore.logService.error(
+      this.editorStore.applicationStore.logService.error(
         LogEvent.create(GRAPH_MANAGER_EVENT.LINEAGE_GENERATION_FAILURE),
         error,
       );
-      this.state.state.editorStore.applicationStore.notificationService.notifyError(
-        error,
+      this.editorStore.applicationStore.notificationService.notifyError(error);
+    } finally {
+      this.generatingLineageAction.complete();
+    }
+  }
+
+  *generateArtifact(): GeneratorFn<void> {
+    try {
+      this.generatingArtifactState.inProgress();
+      const generatedArtifacts =
+        (yield this.editorStore.graphManagerState.graphManager.generateArtifacts(
+          this.editorStore.graphManagerState.graph,
+          this.editorStore.graphEditorMode.getGraphTextInputOption(),
+          [this.state.state.elementPath],
+        )) as unknown as ArtifactGenerationExtensionResult;
+      const dataProductExtension = 'dataProduct';
+      const dataProductArtifact = generatedArtifacts.values.filter(
+        (artifact) => artifact.extension === dataProductExtension,
+      );
+      const dataProductContent =
+        dataProductArtifact[0]?.artifactsByExtensionElements[0]?.files[0]
+          ?.content ?? null;
+
+      if (dataProductContent) {
+        const contentJson = JSON.parse(
+          dataProductContent,
+        ) as V1_DataProductArtifact;
+        const apPlanGeneration = contentJson.accessPointGroups
+          .find(
+            (group: V1_AccessPointGroupInfo) =>
+              group.id === this.state.value.id,
+          )
+          ?.accessPointImplementations.find(
+            (apImplementation: V1_AccessPointImplementation) =>
+              apImplementation.id === this.accessPoint.id,
+          );
+        this.artifactGenerationContent = JSON.stringify(
+          apPlanGeneration,
+          null,
+          2,
+        );
+      } else {
+        throw new Error(
+          'Could not find contents of this data product artifact',
+        );
+      }
+    } catch (error) {
+      this.editorStore.applicationStore.notificationService.notifyError(
+        `Failed to fetch access point plan generation: ${error}`,
       );
     } finally {
-      this.isGeneratingLineage = false;
+      this.generatingArtifactState.complete();
     }
   }
 }
@@ -332,6 +400,10 @@ export class AccessPointGroupState {
     });
   }
 
+  get isRunningProcess(): boolean {
+    return Boolean(this.accessPointStates.find((e) => e.isRunningProcess));
+  }
+
   get containsPublicStereotype(): StereotypeReference | undefined {
     return this.value.stereotypes.find(
       (stereotype) => stereotype.value === this.publicStereotype,