support targeting context accessor

Author: zhiyuanliang-ms

src/feature-management/package-lock.json

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
 
-import { ITargetingContext } from "./common/ITargetingContext";
+import { ITargetingContext } from "./common/targetingContext";
 import { Variant } from "./variant/Variant";
 
 export interface IFeatureManager {

src/feature-management/src/IFeatureManager.ts

@@ -6,3 +6,4 @@ export interface ITargetingContext {
     groups?: string[];
 }
 
+export type TargetingContextAccessor = () => ITargetingContext;

src/feature-management/src/common/ITargetingContext.ts renamed to src/feature-management/src/common/targetingContext.ts

@@ -8,13 +8,14 @@ import { IFeatureFlagProvider } from "./featureProvider.js";
 import { TargetingFilter } from "./filter/TargetingFilter.js";
 import { Variant } from "./variant/Variant.js";
 import { IFeatureManager } from "./IFeatureManager.js";
-import { ITargetingContext } from "./common/ITargetingContext.js";
+import { ITargetingContext, TargetingContextAccessor } from "./common/targetingContext.js";
 import { isTargetedGroup, isTargetedPercentile, isTargetedUser } from "./common/targetingEvaluator.js";
 
 export class FeatureManager implements IFeatureManager {
     #provider: IFeatureFlagProvider;
     #featureFilters: Map<string, IFeatureFilter> = new Map();
     #onFeatureEvaluated?: (event: EvaluationResult) => void;
+    #targetingContextAccessor?: TargetingContextAccessor;
 
     constructor(provider: IFeatureFlagProvider, options?: FeatureManagerOptions) {
         this.#provider = provider;
@@ -27,6 +28,7 @@ export class FeatureManager implements IFeatureManager {
         }
 
         this.#onFeatureEvaluated = options?.onFeatureEvaluated;
+        this.#targetingContextAccessor = options?.targetingContextAccessor;
     }
 
     async listFeatureNames(): Promise<string[]> {
@@ -102,11 +104,19 @@ export class FeatureManager implements IFeatureManager {
         for (const clientFilter of clientFilters) {
             const matchedFeatureFilter = this.#featureFilters.get(clientFilter.name);
             const contextWithFeatureName = { featureName: featureFlag.id, parameters: clientFilter.parameters };
+            let clientFilterEvaluationResult: boolean;
             if (matchedFeatureFilter === undefined) {
                 console.warn(`Feature filter ${clientFilter.name} is not found.`);
-                return false;
+                clientFilterEvaluationResult = false;
             }
-            if (await matchedFeatureFilter.evaluate(contextWithFeatureName, context) === shortCircuitEvaluationResult) {
+            else {
+                let appContext = context;
+                if (clientFilter.name === "Microsoft.Targeting" && this.#targetingContextAccessor !== undefined) {
+                    appContext = this.#targetingContextAccessor();
+                }
+                clientFilterEvaluationResult = await matchedFeatureFilter.evaluate(contextWithFeatureName, appContext);   
+            }
+            if (clientFilterEvaluationResult === shortCircuitEvaluationResult) {
                 return shortCircuitEvaluationResult;
             }
         }
@@ -130,7 +140,10 @@ export class FeatureManager implements IFeatureManager {
         // Evaluate if the feature is enabled.
         result.enabled = await this.#isEnabled(featureFlag, context);
 
-        const targetingContext = context as ITargetingContext;
+        let targetingContext = context as ITargetingContext;
+        if (this.#targetingContextAccessor !== undefined) {
+            targetingContext = this.#targetingContextAccessor();
+        }
         result.targetingId = targetingContext?.userId;
 
         // Determine Variant
@@ -151,7 +164,7 @@ export class FeatureManager implements IFeatureManager {
                 }
             } else {
                 // enabled, assign based on allocation
-                if (context !== undefined && featureFlag.allocation !== undefined) {
+                if (targetingContext !== undefined && featureFlag.allocation !== undefined) {
                     const variantAndReason = await this.#assignVariant(featureFlag, targetingContext);
                     variantDef = variantAndReason.variant;
                     reason = variantAndReason.reason;
@@ -202,6 +215,11 @@ export interface FeatureManagerOptions {
      * The callback function is called only when telemetry is enabled for the feature flag.
      */
     onFeatureEvaluated?: (event: EvaluationResult) => void;
+
+    /**
+     * The accessor function that provides the @see ITargetingContext for targeting evaluation.
+     */
+    targetingContextAccessor?: TargetingContextAccessor;
 }
 
 export class EvaluationResult {

src/feature-management/src/featureManager.ts

@@ -3,7 +3,7 @@
 
 import { IFeatureFilter } from "./FeatureFilter.js";
 import { isTargetedPercentile } from "../common/targetingEvaluator.js";
-import { ITargetingContext } from "../common/ITargetingContext.js";
+import { ITargetingContext } from "../common/targetingContext.js";
 
 type TargetingFilterParameters = {
     Audience: {
@@ -32,10 +32,6 @@ export class TargetingFilter implements IFeatureFilter {
         const { featureName, parameters } = context;
         TargetingFilter.#validateParameters(featureName, parameters);
 
-        if (appContext === undefined) {
-            throw new Error("The app context is required for targeting filter.");
-        }
-
         if (parameters.Audience.Exclusion !== undefined) {
             // check if the user is in the exclusion list
             if (appContext?.userId !== undefined &&

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

@@ -130,16 +130,4 @@ describe("targeting filter", () => {
             expect(featureManager.isEnabled("ComplexTargeting", { userId: "Dave", groups: ["Stage1"] })).eventually.eq(false, "Dave is excluded because he is in the exclusion list"),
         ]);
     });
-
-    it("should throw error if app context is not provided", () => {
-        const dataSource = new Map();
-        dataSource.set("feature_management", {
-            feature_flags: [complexTargetingFeature]
-        });
-
-        const provider = new ConfigurationMapFeatureFlagProvider(dataSource);
-        const featureManager = new FeatureManager(provider);
-
-        return expect(featureManager.isEnabled("ComplexTargeting")).eventually.rejectedWith("The app context is required for targeting filter.");
-    });
 });