@finos/legend-application-studio 28.19.69 → 28.19.70

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/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);
+    }
   }
 }