Merge branch 'zhiyuanliang/targeting-context-accessor' of https://github.com/microsoft/FeatureManagement-JavaScript into zhiyuanliang/ambient-targeting-example

zhiyuanliang-ms · zhiyuanliang-ms · commit cee2d95da1c7 · 2025-03-06T13:08:50.000+08:00
diff --git a/src/feature-management/src/common/targetingContext.ts b/src/feature-management/src/common/targetingContext.ts
@@ -16,6 +16,11 @@ export interface ITargetingContext {
 }
 
 /**
- * Type definition for a function that, when invoked, returns the @see ITargetingContext for targeting evaluation.
+ * Provides access to the current targeting context.
  */
-export type TargetingContextAccessor = () => ITargetingContext;
+export interface ITargetingContextAccessor {
+    /**
+     * Retrieves the current targeting context.
+     */
+    getTargetingContext: () => ITargetingContext | undefined;
+}
diff --git a/src/feature-management/src/featureManager.ts b/src/feature-management/src/featureManager.ts
@@ -8,27 +8,25 @@ import { IFeatureFlagProvider } from "./featureProvider.js";
 import { TargetingFilter } from "./filter/TargetingFilter.js";
 import { Variant } from "./variant/Variant.js";
 import { IFeatureManager } from "./IFeatureManager.js";
-import { ITargetingContext, TargetingContextAccessor } from "./common/targetingContext.js";
+import { ITargetingContext, ITargetingContextAccessor } 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;
+    readonly #provider: IFeatureFlagProvider;
+    readonly #featureFilters: Map<string, IFeatureFilter> = new Map();
+    readonly #onFeatureEvaluated?: (event: EvaluationResult) => void;
+    readonly #targetingContextAccessor?: ITargetingContextAccessor;
 
     constructor(provider: IFeatureFlagProvider, options?: FeatureManagerOptions) {
         this.#provider = provider;
+        this.#onFeatureEvaluated = options?.onFeatureEvaluated;
+        this.#targetingContextAccessor = options?.targetingContextAccessor;
 
-        const builtinFilters = [new TimeWindowFilter(), new TargetingFilter()];
-
+        const builtinFilters = [new TimeWindowFilter(), new TargetingFilter(options?.targetingContextAccessor)];
         // 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);
         }
-
-        this.#onFeatureEvaluated = options?.onFeatureEvaluated;
-        this.#targetingContextAccessor = options?.targetingContextAccessor;
     }
 
     async listFeatureNames(): Promise<string[]> {
@@ -104,19 +102,11 @@ 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.`);
-                clientFilterEvaluationResult = false;
-            }
-            else {
-                if (clientFilter.name === "Microsoft.Targeting") {
-                    clientFilterEvaluationResult = await matchedFeatureFilter.evaluate(contextWithFeatureName, this.#getTargetingContext(appContext));
-                } else {
-                    clientFilterEvaluationResult = await matchedFeatureFilter.evaluate(contextWithFeatureName, appContext);
-                }
+                return false;
             }
-            if (clientFilterEvaluationResult === shortCircuitEvaluationResult) {
+            if (await matchedFeatureFilter.evaluate(contextWithFeatureName, appContext) === shortCircuitEvaluationResult) {
                 return shortCircuitEvaluationResult;
             }
         }
@@ -202,9 +192,11 @@ export class FeatureManager implements IFeatureManager {
     }
 
     #getTargetingContext(context: unknown): ITargetingContext | undefined {
-        let targetingContext = context as ITargetingContext;
-        if (targetingContext === undefined && this.#targetingContextAccessor !== undefined) {
-            targetingContext = this.#targetingContextAccessor();
+        let targetingContext: ITargetingContext | undefined = context as ITargetingContext;
+        if (targetingContext?.userId === undefined &&
+            targetingContext?.groups === undefined &&
+            this.#targetingContextAccessor !== undefined) {
+            targetingContext = this.#targetingContextAccessor.getTargetingContext();
         }
         return targetingContext;
     }
@@ -225,7 +217,7 @@ export interface FeatureManagerOptions {
     /**
      * The accessor function that provides the @see ITargetingContext for targeting evaluation.
      */
-    targetingContextAccessor?: TargetingContextAccessor;
+    targetingContextAccessor?: ITargetingContextAccessor;
 }
 
 export class EvaluationResult {
diff --git a/src/feature-management/src/filter/TargetingFilter.ts b/src/feature-management/src/filter/TargetingFilter.ts
@@ -3,7 +3,7 @@
 
 import { IFeatureFilter } from "./FeatureFilter.js";
 import { isTargetedPercentile } from "../common/targetingEvaluator.js";
-import { ITargetingContext } from "../common/targetingContext.js";
+import { ITargetingContext, ITargetingContextAccessor } from "../common/targetingContext.js";
 
 type TargetingFilterParameters = {
     Audience: {
@@ -26,44 +26,56 @@ type TargetingFilterEvaluationContext = {
 }
 
 export class TargetingFilter implements IFeatureFilter {
-    name: string = "Microsoft.Targeting";
+    readonly name: string = "Microsoft.Targeting";
+    readonly #targetingContextAccessor?: ITargetingContextAccessor;
+
+    constructor(targetingContextAccessor?: ITargetingContextAccessor) {
+        this.#targetingContextAccessor = targetingContextAccessor;
+    }
 
     async evaluate(context: TargetingFilterEvaluationContext, appContext?: ITargetingContext): Promise<boolean> {
         const { featureName, parameters } = context;
         TargetingFilter.#validateParameters(featureName, parameters);
 
+        let targetingContext: ITargetingContext | undefined;
+        if (appContext?.userId !== undefined || appContext?.groups !== undefined) {
+            targetingContext = appContext;
+        } else if (this.#targetingContextAccessor !== undefined) {
+            targetingContext = this.#targetingContextAccessor.getTargetingContext();
+        }
+
         if (parameters.Audience.Exclusion !== undefined) {
             // check if the user is in the exclusion list
-            if (appContext?.userId !== undefined &&
+            if (targetingContext?.userId !== undefined &&
                 parameters.Audience.Exclusion.Users !== undefined &&
-                parameters.Audience.Exclusion.Users.includes(appContext.userId)) {
+                parameters.Audience.Exclusion.Users.includes(targetingContext.userId)) {
                 return false;
             }
             // check if the user is in a group within exclusion list
-            if (appContext?.groups !== undefined &&
+            if (targetingContext?.groups !== undefined &&
                 parameters.Audience.Exclusion.Groups !== undefined) {
                 for (const excludedGroup of parameters.Audience.Exclusion.Groups) {
-                    if (appContext.groups.includes(excludedGroup)) {
+                    if (targetingContext.groups.includes(excludedGroup)) {
                         return false;
                     }
                 }
             }
         }
 
         // check if the user is being targeted directly
-        if (appContext?.userId !== undefined &&
+        if (targetingContext?.userId !== undefined &&
             parameters.Audience.Users !== undefined &&
-            parameters.Audience.Users.includes(appContext.userId)) {
+            parameters.Audience.Users.includes(targetingContext.userId)) {
             return true;
         }
 
         // check if the user is in a group that is being targeted
-        if (appContext?.groups !== undefined &&
+        if (targetingContext?.groups !== undefined &&
             parameters.Audience.Groups !== undefined) {
             for (const group of parameters.Audience.Groups) {
-                if (appContext.groups.includes(group.Name)) {
+                if (targetingContext.groups.includes(group.Name)) {
                     const hint = `${featureName}\n${group.Name}`;
-                    if (await isTargetedPercentile(appContext.userId, hint, 0, group.RolloutPercentage)) {
+                    if (await isTargetedPercentile(targetingContext.userId, hint, 0, group.RolloutPercentage)) {
                         return true;
                     }
                 }
@@ -72,7 +84,7 @@ export class TargetingFilter implements IFeatureFilter {
 
         // check if the user is being targeted by a default rollout percentage
         const hint = featureName;
-        return isTargetedPercentile(appContext?.userId, hint, 0, parameters.Audience.DefaultRolloutPercentage);
+        return isTargetedPercentile(targetingContext?.userId, hint, 0, parameters.Audience.DefaultRolloutPercentage);
     }
 
     static #validateParameters(featureName: string, parameters: TargetingFilterParameters): void {
diff --git a/src/feature-management/src/filter/TimeWindowFilter.ts b/src/feature-management/src/filter/TimeWindowFilter.ts
@@ -15,7 +15,7 @@ type TimeWindowFilterEvaluationContext = {
 }
 
 export class TimeWindowFilter implements IFeatureFilter {
-    name: string = "Microsoft.TimeWindow";
+    readonly name: string = "Microsoft.TimeWindow";
 
     evaluate(context: TimeWindowFilterEvaluationContext): boolean {
         const {featureName, parameters} = context;
diff --git a/src/feature-management/src/index.ts b/src/feature-management/src/index.ts
@@ -5,5 +5,5 @@ export { FeatureManager, FeatureManagerOptions, EvaluationResult, VariantAssignm
 export { ConfigurationMapFeatureFlagProvider, ConfigurationObjectFeatureFlagProvider, IFeatureFlagProvider } from "./featureProvider.js";
 export { createFeatureEvaluationEventProperties } from "./telemetry/featureEvaluationEvent.js";
 export { IFeatureFilter } from "./filter/FeatureFilter.js";
-export { TargetingContextAccessor, ITargetingContext } from "./common/targetingContext.js";
+export { ITargetingContext, ITargetingContextAccessor } from "./common/targetingContext.js";
 export { VERSION } from "./version.js";
diff --git a/src/feature-management/test/targetingFilter.test.ts b/src/feature-management/test/targetingFilter.test.ts
@@ -139,7 +139,11 @@ describe("targeting filter", () => {
 
         let userId = "";
         let groups: string[] = [];
-        const testTargetingContextAccessor = () => ({ userId: userId, groups: groups });
+        const testTargetingContextAccessor = {
+            getTargetingContext: () => {
+              return { userId: userId, groups: groups };
+            }
+        };
         const provider = new ConfigurationMapFeatureFlagProvider(dataSource);
         const featureManager = new FeatureManager(provider, {targetingContextAccessor: testTargetingContextAccessor});
 
diff --git a/src/feature-management/test/variant.test.ts b/src/feature-management/test/variant.test.ts
@@ -96,7 +96,11 @@ describe("variant assignment with targeting context accessor", () => {
     it("should assign variant based on targeting context accessor", async () => {
         let userId = "";
         let groups: string[] = [];
-        const testTargetingContextAccessor = () => ({ userId: userId, groups: groups });
+        const testTargetingContextAccessor = {
+            getTargetingContext: () => {
+              return { userId: userId, groups: groups };
+            }
+        };
         const provider = new ConfigurationObjectFeatureFlagProvider(featureFlagsConfigurationObject);
         const featureManager = new FeatureManager(provider, {targetingContextAccessor: testTargetingContextAccessor});
         userId = "Marsha";

Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ type TimeWindowFilterEvaluationContext = {`
`15`	`15`	`}`
`16`	`16`
`17`	`17`	`export class TimeWindowFilter implements IFeatureFilter {`
`18`		`- name: string = "Microsoft.TimeWindow";`
	`18`	`+ readonly name: string = "Microsoft.TimeWindow";`
`19`	`19`
`20`	`20`	`evaluate(context: TimeWindowFilterEvaluationContext): boolean {`
`21`	`21`	`const {featureName, parameters} = context;`