built-in ConfigurationFeatureProvider supports both object and map

Author: Eskibear

package-lock.json

@@ -37,5 +37,8 @@
     "rollup-plugin-dts": "^6.1.0",
     "tslib": "^2.6.2",
     "typescript": "^5.3.3"
+  },
+  "dependencies": {
+    "chai-as-promised": "^7.1.1"
   }
 }

package.json

@@ -1,12 +1,13 @@
 import { TimewindowFilter } from "./filter/TimeWindowFilter";
 import { IFeatureFilter } from "./filter/FeatureFilter";
-import { FEATURE_FLAGS_KEY, FEATURE_MANAGEMENT_KEY, FeatureDefinition, FeatureManagement, RequirementType } from "./model";
+import { FeatureDefinition, RequirementType } from "./model";
+import { IFeatureProvider } from "./featureProvider";
 
 export class FeatureManager {
-    #provider: IFeatureDefinitionProvider;
+    #provider: IFeatureProvider;
     #featureFilters: Map<string, IFeatureFilter> = new Map();
 
-    constructor(provider: IFeatureDefinitionProvider, options?: FeatureManagerOptions) {
+    constructor(provider: IFeatureProvider, options?: FeatureManagerOptions) {
         this.#provider = provider;
 
         const defaultFilters = [new TimewindowFilter()];
@@ -15,14 +16,16 @@ export class FeatureManager {
         }
     }
 
-    listFeatureNames(): string[] {
-        const featureNameSet = new Set(this.#features.map((feature) => feature.id));
+    async listFeatureNames(): Promise<string[]> {
+        const features = await this.#features();
+        const featureNameSet = new Set(features.map((feature) => feature.id));
         return Array.from(featureNameSet);
     }
 
     // If multiple feature flags are found, the first one takes precedence.
     async isEnabled(featureId: string, context?: unknown): Promise<boolean> {
-        const featureFlag = this.#features.find((flag) => flag.id === featureId);
+        const features = await this.#features();
+        const featureFlag = features.find((flag) => flag.id === featureId);
         if (featureFlag === undefined) {
             // If the feature is not found, then it is disabled.
             return false;
@@ -61,46 +64,13 @@ export class FeatureManager {
         }
     }
 
-    get #features(): FeatureDefinition[] {
-        return this.#provider.getFeatureDefinitions();
+    async #features(): Promise<FeatureDefinition[]> {
+        const features = await this.#provider.getFeatureFlags();
+        return features;
     }
 
 }
 
-export interface IFeatureDefinitionProvider {
-    getFeatureDefinitions(): FeatureDefinition[];
-}
-
-export class MapBasedFeatureDefinitionProvider implements IFeatureDefinitionProvider {
-    #map: Map<string, FeatureManagement>;
-
-    constructor(map: Map<string, FeatureManagement>) {
-        this.#map = map;
-    }
-
-    getFeatureDefinitions(): FeatureDefinition[] {
-        return this.#map.get(FEATURE_MANAGEMENT_KEY)?.[FEATURE_FLAGS_KEY] ?? [];
-    }
-}
-
-export class JsonBasedFeatureDefinitionProvider implements IFeatureDefinitionProvider {
-    #featureFlags: FeatureDefinition[];
-
-    constructor(private json: string) {
-        const featureManagement = JSON.parse(this.json) as FeatureManagement;
-
-        if (featureManagement?.[FEATURE_MANAGEMENT_KEY]?.[FEATURE_FLAGS_KEY] === undefined) {
-            throw new Error("Invalid input data");
-        }
-
-        this.#featureFlags = featureManagement[FEATURE_MANAGEMENT_KEY][FEATURE_FLAGS_KEY];
-    }
-
-    getFeatureDefinitions(): FeatureDefinition[] {
-        return this.#featureFlags;
-    }
-}
-
 interface FeatureManagerOptions {
     customFilters?: IFeatureFilter[];
 }

src/featureManager.ts

@@ -0,0 +1,26 @@
+import { IGettable, isGettable } from "./gettable";
+import { FeatureDefinition, FeatureConfiguration, FEATURE_MANAGEMENT_KEY, FEATURE_FLAGS_KEY } from "./model";
+
+export interface IFeatureProvider {
+    getFeatureFlags(): Promise<FeatureDefinition[]>;
+}
+
+export class ConfigurationFeatureProvider implements IFeatureProvider {
+    #configuration: IGettable | Record<string, unknown>;
+
+    constructor(configuration: Record<string, unknown> | IGettable) {
+        if (typeof configuration !== "object") {
+            throw new Error("Configuration must be an object.");
+        }
+        this.#configuration = configuration;
+    }
+
+    async getFeatureFlags(): Promise<FeatureDefinition[]> {
+        if (isGettable(this.#configuration)) {
+            const featureConfig = this.#configuration.get<FeatureConfiguration>(FEATURE_MANAGEMENT_KEY);
+            return featureConfig?.[FEATURE_FLAGS_KEY] ?? [];
+        } else {
+            return this.#configuration[FEATURE_MANAGEMENT_KEY]?.[FEATURE_FLAGS_KEY] ?? [];
+        }
+    }
+}

src/featureProvider.ts

@@ -0,0 +1,7 @@
+export interface IGettable {
+    get<T>(key: string): T | undefined;
+}
+
+export function isGettable(object: unknown): object is IGettable {
+    return typeof object === "object" && object !== null && typeof (object as IGettable).get === "function";
+}

src/gettable.ts

@@ -1,4 +1,5 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
 
-export { FeatureManager } from "./featureManager";
+export { FeatureManager } from "./featureManager";
+export { ConfigurationFeatureProvider, IFeatureProvider } from "./featureProvider";

src/index.ts

@@ -61,6 +61,6 @@ export interface ClientFilter {
 // Feature Management Section fed into feature manager.
 export const FEATURE_MANAGEMENT_KEY = "FeatureManagement"
 export const FEATURE_FLAGS_KEY = "FeatureFlags"
-export interface FeatureManagement {
+export interface FeatureConfiguration {
   [FEATURE_FLAGS_KEY]: FeatureDefinition[]
 }

src/model.ts

@@ -2,22 +2,25 @@
 // Licensed under the MIT license.
 
 import * as chai from "chai";
+import * as chaiAsPromised from "chai-as-promised";
+chai.use(chaiAsPromised);
 const expect = chai.expect;
 
-import { FeatureManager } from "./exportedApi";
+import { FeatureManager, ConfigurationFeatureProvider } from "./exportedApi";
 
 describe("feature manager", () => {
     it("should load from json string", () => {
-        const json = `{
+        const jsonObject = {
             "FeatureManagement": {
                 "FeatureFlags": [
                     { "id": "Alpha", "description": "", "enabled": true}
                 ]
             }
-        }`;
+        };
 
-        const featureManager = new FeatureManager(json);
-        expect(featureManager.isEnabled("Alpha")).eq(true);
+        const provider = new ConfigurationFeatureProvider(jsonObject);
+        const featureManager = new FeatureManager(provider);
+        return expect(featureManager.isEnabled("Alpha")).eventually.eq(true);
     });
 
     it("should load from map", () => {
@@ -28,8 +31,28 @@ describe("feature manager", () => {
             ],
         });
 
-        const featureManager = new FeatureManager(dataSource);
-        expect(featureManager.isEnabled("Alpha")).eq(true);
+        const provider = new ConfigurationFeatureProvider(dataSource);
+        const featureManager = new FeatureManager(provider);
+        return expect(featureManager.isEnabled("Alpha")).eventually.eq(true);
+    });
+
+    it("should load latest data if source is updated after initialization", () => {
+        const dataSource = new Map();
+        dataSource.set("FeatureManagement", {
+            FeatureFlags: [
+                { id: "Alpha", enabled: true }
+            ],
+        });
+
+        const provider = new ConfigurationFeatureProvider(dataSource);
+        const featureManager = new FeatureManager(provider);
+        dataSource.set("FeatureManagement", {
+            FeatureFlags: [
+                { id: "Alpha", enabled: false }
+            ],
+        });
+
+        return expect(featureManager.isEnabled("Alpha")).eventually.eq(false);
     });
 
     it("shoud evaluate features without conditions", () => {
@@ -41,9 +64,12 @@ describe("feature manager", () => {
             ],
         });
 
-        const featureManager = new FeatureManager(dataSource);
-        expect(featureManager.isEnabled("Alpha")).eq(true);
-        expect(featureManager.isEnabled("Beta")).eq(false);
+        const provider = new ConfigurationFeatureProvider(dataSource);
+        const featureManager = new FeatureManager(provider);
+        return Promise.all([
+            expect(featureManager.isEnabled("Alpha")).eventually.eq(true),
+            expect(featureManager.isEnabled("Beta")).eventually.eq(false)
+        ]);
     });
 
     it("shoud evaluate features with conditions");