@finos/legend-application-studio 28.19.56 → 28.19.58

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/components/workspace-setup/CreateProjectModal.tsx

@@ -669,7 +669,11 @@ export const CreateProjectModal = observer(() => {
       open={setupStore.showCreateProjectModal}
       onClose={closeModal}
       classes={{ container: 'search-modal__container' }}
-      PaperProps={{ classes: { root: 'search-modal__inner-container' } }}
+      slotProps={{
+        paper: {
+          classes: { root: 'search-modal__inner-container' },
+        },
+      }}
     >
       <Modal
         darkMode={

package/src/components/workspace-setup/CreateWorkspaceModal.tsx

@@ -127,11 +127,15 @@ export const CreateWorkspaceModal = observer(
       <Dialog
         open={setupStore.showCreateWorkspaceModal}
         onClose={onClose}
-        TransitionProps={{
-          onEnter: handleEnter,
+        slotProps={{
+          transition: {
+            onEnter: handleEnter,
+          },
+          paper: {
+            classes: { root: 'search-modal__inner-container' },
+          },
         }}
         classes={{ container: 'search-modal__container' }}
-        PaperProps={{ classes: { root: 'search-modal__inner-container' } }}
       >
         <Modal
           darkMode={

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,

package/src/stores/editor/editor-state/element-editor-state/ingest/IngestDefinitionEditorState.ts

@@ -14,7 +14,13 @@
  * limitations under the License.
  */
 
-import { IngestDefinition, type PackageableElement } from '@finos/legend-graph';
+import {
+  type MatViewDataSet,
+  type PackageableElement,
+  type V1_RawLineageModel,
+  GRAPH_MANAGER_EVENT,
+  IngestDefinition,
+} from '@finos/legend-graph';
 import { ElementEditorState } from '../ElementEditorState.js';
 import type { EditorStore } from '../../../EditorStore.js';
 import {
@@ -48,6 +54,7 @@ import {
 import type { AuthContextProps } from 'react-oidc-context';
 import { EXTERNAL_APPLICATION_NAVIGATION__generateUrlWithEditorConfig } from '../../../../../__lib__/LegendStudioNavigation.js';
 import { LEGEND_STUDIO_APP_EVENT } from '../../../../../__lib__/LegendStudioEvent.js';
+import { LineageState } from '@finos/legend-query-builder';
 
 const createEditorInitialConfiguration = (): EditorInitialConfiguration => {
   const config = new EditorInitialConfiguration();
@@ -75,7 +82,9 @@ const PARSER_SECTION = `###Lakehouse`;
 export class IngestDefinitionEditorState extends ElementEditorState {
   validateAndDeployResponse: ValidateAndDeploymentResponse | undefined;
   deploymentState = ActionState.create();
+  lineageGenerationState = ActionState.create();
   deployOnOpen = false;
+  lineageState: LineageState;
 
   constructor(
     editorStore: EditorStore,
@@ -93,6 +102,7 @@ export class IngestDefinitionEditorState extends ElementEditorState {
       setValidateAndDeployResponse: action,
       init_with_deploy: flow,
       deploy: flow,
+      generateLineage: flow,
     });
     if (
       config?.elementEditorConfiguration instanceof
@@ -101,6 +111,7 @@ export class IngestDefinitionEditorState extends ElementEditorState {
       this.deployOnOpen =
         config.elementEditorConfiguration.deployOnOpen ?? false;
     }
+    this.lineageState = new LineageState(this.editorStore.applicationStore);
   }
 
   get deploymentResponse():
@@ -189,6 +200,51 @@ export class IngestDefinitionEditorState extends ElementEditorState {
     }
   }
 
+  getMatviewFuncNames(): string[] {
+    return (
+      this.ingest.TEMPORARY_MATVIEW_FUNCTION_DATA_SETS?.map(
+        (dataset) => dataset.name,
+      ) ?? []
+    );
+  }
+
+  *generateLineage(matviewDataset: MatViewDataSet): GeneratorFn<void> {
+    if (this.lineageGenerationState.isInProgress) {
+      this.editorStore.applicationStore.notificationService.notifyError(
+        'Lineage generation in progress already',
+      );
+      return;
+    }
+    try {
+      this.lineageGenerationState.inProgress();
+
+      const query = matviewDataset.source.function;
+
+      const lineageRawData =
+        (yield this.editorStore.graphManagerState.graphManager.generateLineage(
+          query,
+          undefined,
+          undefined,
+          this.editorStore.graphManagerState.graph,
+          undefined,
+        )) as V1_RawLineageModel;
+      const lineageData =
+        this.editorStore.graphManagerState.graphManager.buildLineage(
+          lineageRawData,
+        );
+      this.lineageState.setLineageData(lineageData);
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.logService.error(
+        LogEvent.create(GRAPH_MANAGER_EVENT.LINEAGE_GENERATION_FAILURE),
+        error,
+      );
+      this.editorStore.applicationStore.notificationService.notifyError(error);
+    } finally {
+      this.lineageGenerationState.complete();
+    }
+  }
+
   reprocess(
     newElement: PackageableElement,
     editorStore: EditorStore,
@@ -202,6 +258,10 @@ export class IngestDefinitionEditorState extends ElementEditorState {
     );
   }
 
+  get validForLineageViewer(): boolean {
+    return Boolean(this.ingest.TEMPORARY_MATVIEW_FUNCTION_DATA_SETS?.length);
+  }
+
   get validationMessage(): string {
     if (!this.ingest.appDirDeployment) {
       return 'No app dir deployment found';