add ParentFeatureFilter

Author: zhiyuanliang-ms

src/feature-management/src/featureManager.ts

@@ -6,6 +6,7 @@ import { IFeatureFilter } from "./filter/featureFilter.js";
 import { FeatureFlag, RequirementType, VariantDefinition } from "./schema/model.js";
 import { IFeatureFlagProvider, IFeatureManager } from "./model.js";
 import { TargetingFilter } from "./filter/targetingFilter.js";
+import { ParentFeatureFilter } from "./filter/parentFeatureFilter.js";
 import { Variant } from "./variant/variant.js";
 import { ITargetingContext, ITargetingContextAccessor } from "./common/targetingContext.js";
 import { isTargetedGroup, isTargetedPercentile, isTargetedUser } from "./common/targetingEvaluator.js";
@@ -21,7 +22,10 @@ export class FeatureManager implements IFeatureManager {
         this.#onFeatureEvaluated = options?.onFeatureEvaluated;
         this.#targetingContextAccessor = options?.targetingContextAccessor;
 
-        const builtinFilters = [new TimeWindowFilter(), new TargetingFilter(options?.targetingContextAccessor)];
+        const builtinFilters = [
+            new TimeWindowFilter(),
+            new TargetingFilter(options?.targetingContextAccessor),
+            new ParentFeatureFilter(this)];
         // If a custom filter shares a name with an existing filter, the custom filter overrides the existing one.
         for (const filter of [...builtinFilters, ...(options?.customFilters ?? [])]) {
             this.#featureFilters.set(filter.name, filter);

src/feature-management/src/filter/parentFeatureFilter.ts

@@ -0,0 +1,32 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+import { IFeatureFilter } from "./featureFilter.js";
+import { IFeatureManager } from "../model.js";
+
+type ParentFeatureFilterEvaluationContext = {
+    featureName: string;
+    parameters: ParentFeatureFilterParameters;
+};
+
+type ParentFeatureFilterParameters = {
+    Name: string
+};
+
+export class ParentFeatureFilter implements IFeatureFilter {
+    readonly name: string = "Microsoft.ParentFeature";
+    readonly #featureManager: IFeatureManager;
+
+    constructor(featureManager: IFeatureManager) {
+        this.#featureManager = featureManager;
+    }
+
+    async evaluate(context: ParentFeatureFilterEvaluationContext): Promise<boolean> {
+        const {featureName, parameters} = context;
+
+        if (!parameters || !parameters.Name) {
+            throw new Error(`ParentFeatureFilter: Missing required parameter 'Name' for feature '${featureName}'.`);
+        }
+        return await this.#featureManager.isEnabled(parameters.Name);
+    }
+}

src/feature-management/test/parentFeatureFilter.test.ts

@@ -0,0 +1,80 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+import * as chai from "chai";
+import chaiAsPromised from "chai-as-promised";
+import { FeatureManager, ConfigurationMapFeatureFlagProvider } from "../src/index.js";
+chai.use(chaiAsPromised);
+const expect = chai.expect;
+
+describe("parent feature filter", () => {
+    it("should evaluate feature with parent feature filter enabled", async () => {
+        const config = {
+            "feature_management": {
+                "feature_flags": [
+                    {
+                        "id": "FeatureA",
+                        "enabled": true,
+                        "conditions": {
+                            "client_filters": [
+                                {
+                                    "name": "Microsoft.ParentFeature",
+                                    "parameters": {
+                                        "Name": "FeatureB"
+                                    }
+                                }
+                            ]
+                        }
+                    },
+                    {
+                        "id": "FeatureB",
+                        "enabled": true
+                    }
+                ]
+            }
+        };
+
+        const dataSource = new Map();
+        dataSource.set("feature_management", config.feature_management);
+        const provider = new ConfigurationMapFeatureFlagProvider(dataSource);
+        const featureManager = new FeatureManager(provider);
+
+        const result = await featureManager.isEnabled("FeatureA");
+        expect(result).to.equal(true);
+    });
+
+    it("should evaluate feature with parent feature filter disabled", async () => {
+        const config = {
+            "feature_management": {
+                "feature_flags": [
+                    {
+                        "id": "FeatureA",
+                        "enabled": true,
+                        "conditions": {
+                            "client_filters": [
+                                {
+                                    "name": "ParentFeature",
+                                    "parameters": {
+                                        "Name": "FeatureB"
+                                    }
+                                }
+                            ]
+                        }
+                    },
+                    {
+                        "id": "FeatureB",
+                        "enabled": false
+                    }
+                ]
+            }
+        };
+
+        const dataSource = new Map();
+        dataSource.set("feature_management", config.feature_management);
+        const provider = new ConfigurationMapFeatureFlagProvider(dataSource);
+        const featureManager = new FeatureManager(provider);
+
+        const result = await featureManager.isEnabled("FeatureA");
+        expect(result).to.equal(false);
+    });
+});