@finos/legend-application-studio 28.19.69 → 28.19.71

package/src/stores/editor/EditorGraphState.ts

@@ -799,15 +799,22 @@ export class EditorGraphState {
     projectDependencies: ProjectDependency[],
   ): Promise<ProjectDependencyCoordinates[]> {
     return Promise.all(
-      projectDependencies.map(async (dep) =>
-        Promise.resolve(
+      projectDependencies.map(async (dep) => {
+        const exclusionCoordinates = (dep.exclusions ?? []).map(
+          (exclusion) => ({
+            groupId: guaranteeNonNullable(exclusion.groupId),
+            artifactId: guaranteeNonNullable(exclusion.artifactId),
+          }),
+        );
+        return Promise.resolve(
           new ProjectDependencyCoordinates(
             guaranteeNonNullable(dep.groupId),
             guaranteeNonNullable(dep.artifactId),
             dep.versionId,
+            exclusionCoordinates.length > 0 ? exclusionCoordinates : undefined,
           ),
-        ),
-      ),
+        );
+      }),
     );
   }
 

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

@@ -64,6 +64,7 @@ import {
   V1_RemoteEngine,
   DataElementReference,
   DataElement,
+  DataProductDiagram,
 } from '@finos/legend-graph';
 import type { EditorStore } from '../../../EditorStore.js';
 import { ElementEditorState } from '../ElementEditorState.js';
@@ -98,8 +99,10 @@ import {
   dataProduct_addAccessPoint,
   dataProduct_addAccessPointGroup,
   supportInfo_addExpertise,
+  modelAccessPointGroup_addDiagram,
   dataProduct_deleteAccessPoint,
   dataProduct_deleteAccessPointGroup,
+  modelAccessPointGroup_removeDiagram,
   dataProduct_swapAccessPointGroups,
   modelAccessPointGroup_addCompatibleRuntime,
   modelAccessPointGroup_addElement,
@@ -121,6 +124,7 @@ import type {
   LakehouseIngestionManager,
 } from '@finos/legend-server-lakehouse';
 import { deserialize } from 'serializr';
+import { Diagram } from '@finos/legend-extension-dsl-diagram';
 
 export enum DATA_PRODUCT_TAB {
   HOME = 'Home',
@@ -762,11 +766,13 @@ export class AccessPointGroupState {
 
 export class ModelAccessPointGroupState extends AccessPointGroupState {
   declare value: ModelAccessPointGroup;
+  readonly editorState: DataProductEditorState;
   showNewModal = false;
 
   constructor(val: ModelAccessPointGroup, editorState: DataProductEditorState) {
     super(val, editorState);
     this.value = val;
+    this.editorState = editorState;
   }
 
   setMapping(mapping: Mapping): void {
@@ -793,6 +799,23 @@ export class ModelAccessPointGroupState extends AccessPointGroupState {
     }
   }
 
+  getCompatibleDiagramOptions(): {
+    label: string;
+    value: PackageableElement;
+  }[] {
+    const currentDiagrams = this.value.diagrams.map(
+      (diagram) => diagram.diagram,
+    );
+
+    return this.state.editorStore.graphManagerState.graph.allOwnElements
+      .filter((element): element is Diagram => element instanceof Diagram)
+      .filter((diagram) => !currentDiagrams.includes(diagram))
+      .map((diagram) => ({
+        label: diagram.path,
+        value: diagram,
+      }));
+  }
+
   removeCompatibleRuntime(runtime: DataProductRuntimeInfo): void {
     modelAccessPointGroup_removeCompatibleRuntime(this.value, runtime);
     if (runtime === this.value.defaultRuntime) {
@@ -804,6 +827,18 @@ export class ModelAccessPointGroupState extends AccessPointGroupState {
     }
   }
 
+  addDiagram = (option: { label: string; value: PackageableElement }): void => {
+    const diagramValue = option.value;
+    const newDiagram = new DataProductDiagram();
+    newDiagram.title = diagramValue.name;
+    newDiagram.diagram = diagramValue;
+    modelAccessPointGroup_addDiagram(this.value, newDiagram);
+  };
+
+  handleRemoveDiagram = (diagram: DataProductDiagram): void => {
+    modelAccessPointGroup_removeDiagram(this.value, diagram);
+  };
+
   addFeaturedElement(element: DataProductElement): void {
     const elementPointer = observe_DataProductElementScope(
       new DataProductElementScope(),

package/src/stores/editor/editor-state/project-configuration-editor-state/ProjectConfigurationEditorState.ts

@@ -106,6 +106,8 @@ export class ProjectConfigurationEditorState extends EditorState {
       setProjectConfiguration: action,
       setSelectedTab: action,
       setManualOverwrite: action,
+      syncExclusionsToProjectDependencies: action,
+      loadExclusionsFromProjectDependencies: action,
       fectchAssociatedProjectsAndVersions: flow,
       updateProjectConfiguration: flow,
       updateToLatestStructure: flow,
@@ -131,6 +133,7 @@ export class ProjectConfigurationEditorState extends EditorState {
 
   setProjectConfiguration(projectConfiguration: ProjectConfiguration): void {
     this.projectConfiguration = projectConfiguration;
+    this.loadExclusionsFromProjectDependencies();
   }
 
   setSelectedTab(tab: CONFIGURATION_EDITOR_TAB): void {
@@ -191,6 +194,24 @@ export class ProjectConfigurationEditorState extends EditorState {
     );
   }
 
+  syncExclusionsToProjectDependencies(): void {
+    this.currentProjectConfiguration.projectDependencies.forEach((dep) => {
+      const exclusions = this.projectDependencyEditorState.getExclusions(
+        dep.projectId,
+      );
+      dep.setExclusions(exclusions);
+    });
+  }
+
+  loadExclusionsFromProjectDependencies(): void {
+    this.projectConfiguration?.projectDependencies.forEach((dep) => {
+      if (dep.exclusions && dep.exclusions.length > 0) {
+        this.projectDependencyEditorState.dependencyExclusions[dep.projectId] =
+          [...dep.exclusions];
+      }
+    });
+  }
+
   *fectchAssociatedProjectsAndVersions(): GeneratorFn<void> {
     this.fetchingProjectVersionsState.inProgress();
     try {
@@ -234,6 +255,9 @@ export class ProjectConfigurationEditorState extends EditorState {
   ): GeneratorFn<void> {
     try {
       this.updatingConfigurationState.inProgress();
+
+      this.syncExclusionsToProjectDependencies();
+
       yield this.editorStore.sdlcServerClient.updateConfiguration(
         this.editorStore.sdlcState.activeProject.projectId,
         this.editorStore.sdlcState.activeWorkspace,
@@ -340,6 +364,8 @@ export class ProjectConfigurationEditorState extends EditorState {
       showLoading: true,
     });
     try {
+      this.syncExclusionsToProjectDependencies();
+
       const updateProjectConfigurationCommand =
         new UpdateProjectConfigurationCommand(
           this.currentProjectConfiguration.groupId,

package/src/stores/editor/editor-state/project-configuration-editor-state/ProjectDependencyEditorState.ts

@@ -24,6 +24,7 @@ import {
   assertErrorThrown,
   LogEvent,
   isNonNullable,
+  guaranteeNonNullable,
   uuid,
 } from '@finos/legend-shared';
 import {
@@ -39,7 +40,11 @@ import {
 } from '@finos/legend-server-depot';
 import type { TreeData, TreeNodeData } from '@finos/legend-art';
 import { LEGEND_STUDIO_APP_EVENT } from '../../../../__lib__/LegendStudioEvent.js';
-import type { ProjectConfiguration } from '@finos/legend-server-sdlc';
+import {
+  ProjectDependencyExclusion,
+  type ProjectConfiguration,
+} from '@finos/legend-server-sdlc';
+import { generateGAVCoordinates } from '@finos/legend-storage';
 
 export abstract class ProjectDependencyConflictTreeNodeData
   implements TreeNodeData
@@ -299,6 +304,12 @@ export class ProjectDependencyEditorState {
   expandConflictsState = ActionState.create();
   buildConflictPathState = ActionState.create();
 
+  // Exclusions management
+  selectedDependencyForExclusions: ProjectDependencyVersionNode | undefined;
+  dependencyExclusions: {
+    [dependencyId: string]: ProjectDependencyExclusion[];
+  } = {};
+
   constructor(
     configState: ProjectConfigurationEditorState,
     editorStore: EditorStore,
@@ -312,6 +323,8 @@ export class ProjectDependencyEditorState {
       reportTab: observable,
       expandConflictsState: observable,
       buildConflictPathState: observable,
+      selectedDependencyForExclusions: observable,
+      dependencyExclusions: observable,
       setReportTab: action,
       expandAllConflicts: action,
       setFlattenDependencyTreeData: action,
@@ -320,6 +333,15 @@ export class ProjectDependencyEditorState {
       setDependencyTreeData: action,
       buildConflictPaths: action,
       setConflictStates: action,
+      setSelectedDependencyForExclusions: action,
+      addExclusion: action,
+      addExclusionByCoordinate: action,
+      removeExclusion: action,
+      removeExclusionByCoordinate: action,
+      clearExclusions: action,
+      getExclusions: action,
+      getExclusionCoordinates: action,
+      syncExclusionsToProjectDependency: action,
       fetchDependencyReport: flow,
     });
     this.configState = configState;
@@ -376,6 +398,149 @@ export class ProjectDependencyEditorState {
     return this.configState.projectConfiguration;
   }
 
+  setSelectedDependencyForExclusions(
+    dependency: ProjectDependencyVersionNode | undefined,
+  ): void {
+    this.selectedDependencyForExclusions = dependency;
+  }
+
+  addExclusion(
+    dependencyId: string,
+    exclusion: ProjectDependencyExclusion,
+  ): void {
+    if (!this.dependencyExclusions[dependencyId]) {
+      this.dependencyExclusions[dependencyId] = [];
+    }
+    const existingExclusion = this.findExistingExclusion(
+      dependencyId,
+      generateGAVCoordinates(
+        guaranteeNonNullable(exclusion.groupId),
+        guaranteeNonNullable(exclusion.artifactId),
+        undefined,
+      ),
+    );
+    if (!existingExclusion) {
+      this.dependencyExclusions[dependencyId].push(exclusion);
+      this.syncExclusionsToProjectDependency(dependencyId);
+    }
+  }
+
+  addExclusionByCoordinate(
+    dependencyId: string,
+    exclusionCoordinate: string,
+  ): void {
+    const exclusion =
+      ProjectDependencyExclusion.fromCoordinate(exclusionCoordinate);
+    this.addExclusion(dependencyId, exclusion);
+  }
+
+  removeExclusion(
+    dependencyId: string,
+    exclusion: ProjectDependencyExclusion,
+  ): void {
+    if (this.dependencyExclusions[dependencyId]) {
+      const coordinate = generateGAVCoordinates(
+        guaranteeNonNullable(exclusion.groupId),
+        guaranteeNonNullable(exclusion.artifactId),
+        undefined,
+      );
+      const index = this.findExclusionIndex(dependencyId, coordinate);
+      if (index > -1) {
+        this.dependencyExclusions[dependencyId].splice(index, 1);
+      }
+      if (this.dependencyExclusions[dependencyId].length === 0) {
+        delete this.dependencyExclusions[dependencyId];
+      }
+      this.syncExclusionsToProjectDependency(dependencyId);
+    }
+  }
+
+  removeExclusionByCoordinate(
+    dependencyId: string,
+    exclusionCoordinate: string,
+  ): void {
+    if (this.dependencyExclusions[dependencyId]) {
+      const index = this.findExclusionIndex(dependencyId, exclusionCoordinate);
+      if (index > -1) {
+        this.dependencyExclusions[dependencyId].splice(index, 1);
+      }
+      if (this.dependencyExclusions[dependencyId].length === 0) {
+        delete this.dependencyExclusions[dependencyId];
+      }
+      this.syncExclusionsToProjectDependency(dependencyId);
+    }
+  }
+
+  clearExclusions(dependencyId?: string): void {
+    if (dependencyId) {
+      delete this.dependencyExclusions[dependencyId];
+      this.syncExclusionsToProjectDependency(dependencyId);
+    } else {
+      this.dependencyExclusions = {};
+      this.projectConfiguration?.projectDependencies.forEach((dep) => {
+        this.syncExclusionsToProjectDependency(dep.projectId);
+      });
+    }
+  }
+
+  getExclusions(dependencyId: string): ProjectDependencyExclusion[] {
+    return this.dependencyExclusions[dependencyId] ?? [];
+  }
+
+  getExclusionCoordinates(dependencyId: string): string[] {
+    const exclusions = this.getExclusions(dependencyId);
+    return exclusions.map((e) =>
+      generateGAVCoordinates(
+        guaranteeNonNullable(e.groupId),
+        guaranteeNonNullable(e.artifactId),
+        undefined,
+      ),
+    );
+  }
+
+  private findExistingExclusion(
+    dependencyId: string,
+    coordinate: string,
+  ): ProjectDependencyExclusion | undefined {
+    if (!this.dependencyExclusions[dependencyId]) {
+      return undefined;
+    }
+    for (let i = 0; i < this.dependencyExclusions[dependencyId].length; i++) {
+      const exclusion = guaranteeNonNullable(
+        this.dependencyExclusions[dependencyId][i],
+      );
+      const exclusionCoordinate = generateGAVCoordinates(
+        guaranteeNonNullable(exclusion.groupId),
+        guaranteeNonNullable(exclusion.artifactId),
+        undefined,
+      );
+      if (exclusionCoordinate === coordinate) {
+        return this.dependencyExclusions[dependencyId][i];
+      }
+    }
+    return undefined;
+  }
+
+  private findExclusionIndex(dependencyId: string, coordinate: string): number {
+    if (!this.dependencyExclusions[dependencyId]) {
+      return -1;
+    }
+    for (let i = 0; i < this.dependencyExclusions[dependencyId].length; i++) {
+      const exclusion = guaranteeNonNullable(
+        this.dependencyExclusions[dependencyId][i],
+      );
+      const exclusionCoordinate = generateGAVCoordinates(
+        guaranteeNonNullable(exclusion.groupId),
+        guaranteeNonNullable(exclusion.artifactId),
+        undefined,
+      );
+      if (exclusionCoordinate === coordinate) {
+        return i;
+      }
+    }
+    return -1;
+  }
+
   *fetchDependencyReport(): GeneratorFn<void> {
     try {
       this.fetchingDependencyInfoState.inProgress();
@@ -442,5 +607,17 @@ export class ProjectDependencyEditorState {
   clearTrees(): void {
     this.flattenDependencyTreeData = undefined;
     this.dependencyTreeData = undefined;
+    this.selectedDependencyForExclusions = undefined;
+  }
+
+  syncExclusionsToProjectDependency(dependencyId: string): void {
+    const projectDependency =
+      this.projectConfiguration?.projectDependencies.find(
+        (dep) => dep.projectId === dependencyId,
+      );
+    if (projectDependency) {
+      const exclusions = this.getExclusions(dependencyId);
+      projectDependency.setExclusions(exclusions);
+    }
   }
 }

package/src/stores/editor/sidebar-state/dev-metadata/DevMetadataState.ts

@@ -17,48 +17,48 @@
 import {
   ActionState,
   assertErrorThrown,
-  assertNonEmptyString,
   assertNonNullable,
   assertTrue,
-  filterByType,
   type GeneratorFn,
 } from '@finos/legend-shared';
 import type { EditorStore } from '../../EditorStore.js';
 import { action, flow, makeObservable, observable } from 'mobx';
-import { type DevMetadataResult, IngestDefinition } from '@finos/legend-graph';
-import { generateGAVCoordinates } from '@finos/legend-storage';
+import {
+  type DeployProjectResponse,
+  MetadataRequestOptions,
+} from '@finos/legend-graph';
 
 export class DevMetadataState {
   readonly editorStore: EditorStore;
-  result: DevMetadataResult | undefined;
+  result: DeployProjectResponse | undefined;
+  options: MetadataRequestOptions = new MetadataRequestOptions();
   pushState = ActionState.create();
-  did = '';
 
   constructor(editorStore: EditorStore) {
     this.editorStore = editorStore;
 
     makeObservable(this, {
       pushState: observable,
-      did: observable,
-      setDid: action,
       push: flow,
-      init: action,
+      options: observable,
+      setOptions: action,
     });
   }
 
-  setDid(did: string): void {
-    this.did = did;
+  setOptions(options: MetadataRequestOptions): void {
+    this.options = options;
   }
 
-  init(): void {
-    if (!this.did) {
-      const ingestDID = this.editorStore.graphManagerState.graph.allElements
-        .filter(filterByType(IngestDefinition))[0]
-        ?.appDirDeployment?.appDirId?.toString();
-      if (ingestDID) {
-        this.setDid(ingestDID);
-      }
+  get projectGAV(): { groupId: string; artifactId: string } | undefined {
+    const currentProjectConfiguration =
+      this.editorStore.projectConfigurationEditorState.projectConfiguration;
+    if (currentProjectConfiguration) {
+      return {
+        groupId: currentProjectConfiguration.groupId,
+        artifactId: currentProjectConfiguration.artifactId,
+      };
     }
+    return undefined;
   }
 
   *push(): GeneratorFn<void> {
@@ -78,34 +78,23 @@ export class DevMetadataState {
         currentProjectConfiguration,
         'Project Name required to push to dev mode',
       );
-      const projectId = generateGAVCoordinates(
-        currentProjectConfiguration.groupId,
-        currentProjectConfiguration.artifactId,
-        undefined,
-      );
-      assertNonEmptyString(this.did, 'DID required to push to dev mode');
       this.pushState.inProgress();
-      this.editorStore.applicationStore.alertService.setBlockingAlert({
-        message: 'Pushing to Dev Mode',
-        showLoading: true,
-      });
       const result =
         (yield this.editorStore.graphManagerState.graphManager.pushToDevMetadata(
-          this.did,
-          projectId,
+          currentProjectConfiguration.groupId,
+          currentProjectConfiguration.artifactId,
+          undefined,
+          this.options,
           this.editorStore.graphManagerState.graph,
-        )) as DevMetadataResult;
+        )) as DeployProjectResponse;
       this.result = result;
-      this.editorStore.applicationStore.notificationService.notifySuccess(
-        `Pushed to dev mode`,
-      );
+      this.pushState.complete();
     } catch (error) {
       assertErrorThrown(error);
-      this.pushState.fail();
-    } finally {
-      this.editorStore.applicationStore.alertService.setBlockingAlert(
-        undefined,
+      this.editorStore.applicationStore.notificationService.notifyError(
+        `Error pushing to dev metadata: ${error.message}`,
       );
+      this.pushState.fail();
     }
   }
 }

package/src/stores/graph-modifier/DSL_DataProduct_GraphModifierHelper.ts

@@ -28,10 +28,10 @@ import {
   observe_SupportInfo,
   observer_DataProductLink,
   SupportInfo,
-  type ModelAccessPointGroup,
   type DataProductRuntimeInfo,
   type PackageableElementReference,
   type Mapping,
+  type ModelAccessPointGroup,
   type DataProductDiagram,
   type DataProductElementScope,
   observe_APG,