fix: feature-dependencies-removed event should not be created always (#9100)

Currently, every time you archived feature, it created
feature-dependencies-removed event.

This PR adds a check to only create events for those features that have
dependency.

src/lib/features/dependent-features/dependent-features-service.ts

@@ -214,9 +214,17 @@ export class DependentFeaturesService {
         projectId: string,
         auditUser: IAuditUser,
     ): Promise<void> {
-        await this.dependentFeaturesStore.deleteAll(features);
+        const dependencies =
+            await this.dependentFeaturesReadModel.getDependencies(features);
+        const featuresWithDependencies = dependencies.map(
+            (dependency) => dependency.feature,
+        );
+        if (featuresWithDependencies.length > 0) {
+            await this.dependentFeaturesStore.deleteAll(
+                featuresWithDependencies,
+            );
             await this.eventService.storeEvents(
-            features.map(
+                featuresWithDependencies.map(
                     (feature) =>
                         new FeatureDependenciesRemovedEvent({
                             project: projectId,
@@ -226,6 +234,7 @@ export class DependentFeaturesService {
                 ),
             );
         }
+    }
 
     async getPossibleParentFeatures(feature: string): Promise<string[]> {
         return this.dependentFeaturesReadModel.getPossibleParentFeatures(

src/lib/features/dependent-features/dependent.features.e2e.test.ts

@@ -58,6 +58,7 @@ beforeEach(async () => {
     await db.stores.dependentFeaturesStore.deleteAll();
     await db.stores.featureToggleStore.deleteAll();
     await db.stores.featureEnvironmentStore.deleteAll();
+    await db.stores.eventStore.deleteAll();
 });
 
 const addFeatureDependency = async (
@@ -168,11 +169,13 @@ const checkDependenciesExist = async (expectedCode = 200) => {
 test('should add and delete feature dependencies', async () => {
     const parent = uuidv4();
     const child = uuidv4();
+    const child2 = uuidv4();
     await app.createFeature(parent);
     await app.createFeature(child);
+    await app.createFeature(child2);
 
     const { body: options } = await getPossibleParentFeatures(child);
-    expect(options).toStrictEqual([parent]);
+    expect(options).toMatchObject([parent, child2].sort());
 
     // save explicit enabled and variants
     await addFeatureDependency(child, {
@@ -185,14 +188,21 @@ test('should add and delete feature dependencies', async () => {
         variants: ['variantB'],
     });
 
-    await deleteFeatureDependency(child, parent); // single
+    await addFeatureDependency(child2, {
-    await deleteFeatureDependencies(child); // all
+        feature: parent,
+        enabled: false,
+    });
 
-    expect(await getRecordedEventTypesForDependencies()).toStrictEqual([
+    await deleteFeatureDependency(child, parent); // single
+    await deleteFeatureDependencies(child2); // all
+
+    const eventTypes = await getRecordedEventTypesForDependencies();
+    expect(eventTypes).toStrictEqual([
         FEATURE_DEPENDENCIES_REMOVED,
         FEATURE_DEPENDENCY_REMOVED,
         FEATURE_DEPENDENCY_ADDED,
         FEATURE_DEPENDENCY_ADDED,
+        FEATURE_DEPENDENCY_ADDED,
     ]);
 });
 
@@ -338,3 +348,35 @@ test('should not allow to add dependency to feature from another project', async
         403,
     );
 });
+test('should create feature-dependency-removed when archiving and has dependency', async () => {
+    const child = uuidv4();
+    const parent = uuidv4();
+    await app.createFeature(parent);
+    await app.createFeature(child);
+
+    await addFeatureDependency(child, {
+        feature: parent,
+    });
+    await app.archiveFeature(child);
+    const events = await eventStore.getEvents();
+    expect(events).toEqual(
+        expect.arrayContaining([
+            expect.objectContaining({ type: 'feature-dependencies-removed' }),
+        ]),
+    );
+});
+
+test('should not create feature-dependency-removed when archiving and no dependency', async () => {
+    const child = uuidv4();
+    const parent = uuidv4();
+    await app.createFeature(parent);
+    await app.createFeature(child);
+
+    await app.archiveFeature(child);
+    const events = await eventStore.getEvents();
+    expect(events).not.toEqual(
+        expect.arrayContaining([
+            expect.objectContaining({ type: 'feature-dependencies-removed' }),
+        ]),
+    );
+});