rename new feature flags to 'enhanced*', drop 'classic' for old feature flags

linglingye001 · linglingye001 · commit 0ff2561e8d54 · 2026-07-30T14:51:38.000+08:00
diff --git a/src/appConfigurationImpl.ts b/src/appConfigurationImpl.ts
@@ -128,15 +128,15 @@ export class AzureAppConfigurationImpl implements AzureAppConfiguration {
      */
     #kvPageWatchers: PagedSettingsWatcher[] = [];
     /**
-     * Page watchers for classic feature flags, derived from
+     * Page watchers for feature flags, derived from
      * @see AzureAppConfigurationOptions.featureFlagOptions.selectors with each key filter prefixed by `.appconfig.featureflag/`.
      */
-    #classicFfPageWatchers: PagedSettingsWatcher[] = [];
+    #ffPageWatchers: PagedSettingsWatcher[] = [];
     /**
-     * Page watchers for feature flags loaded from feature flag endpoint, derived from
+     * Page watchers for enhanced feature flags loaded from the dedicated feature flag endpoint, derived from
      * @see AzureAppConfigurationOptions.featureFlagOptions.selectors.
      */
-    #ffPageWatchers: PagedSettingsWatcher[] = [];
+    #enhancedFfPageWatchers: PagedSettingsWatcher[] = [];
 
     // Load balancing
     #lastSuccessfulEndpoint: string = "";
@@ -198,8 +198,8 @@ export class AzureAppConfigurationImpl implements AzureAppConfiguration {
         if (options?.featureFlagOptions?.enabled === true) {
             this.#featureFlagEnabled = true;
             // validate feature flag selectors, only load feature flags when enabled
-            this.#classicFfPageWatchers = getClassicFeatureFlagPageWatchers(options.featureFlagOptions.selectors);
-            this.#ffPageWatchers = getPageWatchers(options.featureFlagOptions.selectors);
+            this.#ffPageWatchers = getFeatureFlagPageWatchers(options.featureFlagOptions.selectors);
+            this.#enhancedFfPageWatchers = getPageWatchers(options.featureFlagOptions.selectors);
 
             if (options.featureFlagOptions.refresh?.enabled === true) {
                 this.#featureFlagRefreshEnabled = true;
@@ -419,9 +419,9 @@ export class AzureAppConfigurationImpl implements AzureAppConfiguration {
                     await this.#loadSelectedKeyValues();
 
                     if (this.#featureFlagEnabled) {
-                        const classicFeatureFlags: ConfigurationSetting[] = await this.#loadClassicFeatureFlags();
-                        const featureFlags: FeatureFlag[] = await this.#loadFeatureFlags();
-                        await this.#setFeatureFlags(classicFeatureFlags, featureFlags);
+                        const featureFlags: ConfigurationSetting[] = await this.#loadFeatureFlags();
+                        const enhancedFeatureFlags: FeatureFlag[] = await this.#loadEnhancedFeatureFlags();
+                        await this.#setFeatureFlags(featureFlags, enhancedFeatureFlags);
                     }
                     this.#isInitialLoadCompleted = true;
                     break;
@@ -614,10 +614,10 @@ export class AzureAppConfigurationImpl implements AzureAppConfiguration {
         }
     }
 
-    async #loadClassicFeatureFlags(): Promise<ConfigurationSetting[]> {
-        const classicFeatureFlags: Map<string, ConfigurationSetting> = new Map<string, ConfigurationSetting>();
+    async #loadFeatureFlags(): Promise<ConfigurationSetting[]> {
+        const featureFlags: Map<string, ConfigurationSetting> = new Map<string, ConfigurationSetting>();
         // Deep copy selectors to avoid modification if current client fails.
-        const watchersToUpdate: PagedSettingsWatcher[] = structuredClone(this.#classicFfPageWatchers);
+        const watchersToUpdate: PagedSettingsWatcher[] = structuredClone(this.#ffPageWatchers);
 
         for (const selector of watchersToUpdate) {
             let settings: ConfigurationSetting[] = [];
@@ -637,19 +637,19 @@ export class AzureAppConfigurationImpl implements AzureAppConfiguration {
 
             for (const setting of settings) {
                 if (isFeatureFlag(setting)) {
-                    classicFeatureFlags.set(setting.key, setting);
+                    featureFlags.set(setting.key, setting);
                 }
             }
         }
 
-        this.#classicFfPageWatchers = watchersToUpdate;
-        return Array.from(classicFeatureFlags.values());
+        this.#ffPageWatchers = watchersToUpdate;
+        return Array.from(featureFlags.values());
     }
 
-    async #loadFeatureFlags(): Promise<FeatureFlag[]> {
+    async #loadEnhancedFeatureFlags(): Promise<FeatureFlag[]> {
         const loadedFeatureFlags: Map<string, FeatureFlag> = new Map<string, FeatureFlag>();
         // Deep copy selectors to avoid modification if current client fails.
-        const watchersToUpdate: PagedSettingsWatcher[] = structuredClone(this.#ffPageWatchers);
+        const watchersToUpdate: PagedSettingsWatcher[] = structuredClone(this.#enhancedFfPageWatchers);
 
         for (const selector of watchersToUpdate) {
             if (selector.snapshotName) {
@@ -660,39 +660,39 @@ export class AzureAppConfigurationImpl implements AzureAppConfiguration {
                 labelFilter: selector.labelFilter,
                 tagsFilter: selector.tagFilters
             };
-            const { items, pageWatchers } = await this.#listFeatureFlags(listOptions);
+            const { items, pageWatchers } = await this.#listEnhancedFeatureFlags(listOptions);
             selector.pageWatchers = pageWatchers;
             for (const featureFlag of items) {
                 loadedFeatureFlags.set(featureFlag.name, featureFlag);
             }
         }
 
-        this.#ffPageWatchers = watchersToUpdate;
+        this.#enhancedFfPageWatchers = watchersToUpdate;
         return Array.from(loadedFeatureFlags.values());
     }
 
-    async #setFeatureFlags(classicFeatureFlags: ConfigurationSetting[], featureFlags: FeatureFlag[]): Promise<void> {
+    async #setFeatureFlags(featureFlags: ConfigurationSetting[], enhancedFeatureFlags: FeatureFlag[]): Promise<void> {
         if (this.#requestTracingEnabled && this.#featureFlagTracing !== undefined) {
             // Reset old feature flag tracing in order to track the information present in the current response from server.
             this.#featureFlagTracing.reset();
         }
 
         // Track whether enhanced feature flags were loaded.
-        this.#useEnhancedFeatureFlag = featureFlags.length > 0;
-
-        // Exclude any classic feature flags that are superseded by a standalone feature flag with the same name.
-        const ineligibleClassicFfKeys = new Set(featureFlags.map(ff => featureFlagPrefix + ff.name));
-        const eligibleClassicFeatureFlags = await Promise.all(
-            classicFeatureFlags
-                .filter(setting => !ineligibleClassicFfKeys.has(setting.key))
-                .map(setting => this.#parseClassicFeatureFlag(setting))
+        this.#useEnhancedFeatureFlag = enhancedFeatureFlags.length > 0;
+
+        // Exclude any feature flags that are superseded by an enhanced feature flag with the same name.
+        const ineligibleFeatureFlagKeys = new Set(enhancedFeatureFlags.map(ff => featureFlagPrefix + ff.name));
+        const eligibleFeatureFlags = await Promise.all(
+            featureFlags
+                .filter(setting => !ineligibleFeatureFlagKeys.has(setting.key))
+                .map(setting => this.#parseFeatureFlag(setting))
         );
-        const parsedFeatureFlags = await Promise.all(
-            featureFlags.map(ff => this.#parseFeatureFlag(ff))
+        const parsedEnhancedFeatureFlags = await Promise.all(
+            enhancedFeatureFlags.map(ff => this.#parseEnhancedFeatureFlag(ff))
         );
 
         // feature_management is a reserved key, and feature_flags is an array of feature flags
-        this.#configMap.set(FEATURE_MANAGEMENT_KEY_NAME, { [FEATURE_FLAGS_KEY_NAME]: [...eligibleClassicFeatureFlags, ...parsedFeatureFlags] });
+        this.#configMap.set(FEATURE_MANAGEMENT_KEY_NAME, { [FEATURE_FLAGS_KEY_NAME]: [...eligibleFeatureFlags, ...parsedEnhancedFeatureFlags] });
     }
 
     /**
@@ -755,13 +755,13 @@ export class AzureAppConfigurationImpl implements AzureAppConfiguration {
             return Promise.resolve(false);
         }
 
-        const needRefresh = await this.#checkConfigurationSettingsChange(this.#classicFfPageWatchers) ||
-            await this.#checkFeatureFlagsChange(this.#ffPageWatchers);
+        const needRefresh = await this.#checkConfigurationSettingsChange(this.#ffPageWatchers) ||
+            await this.#checkEnhancedFeatureFlagsChange(this.#enhancedFfPageWatchers);
 
         if (needRefresh) {
-            const classicFeatureFlags: ConfigurationSetting[] = await this.#loadClassicFeatureFlags();
-            const featureFlags: FeatureFlag[] = await this.#loadFeatureFlags();
-            await this.#setFeatureFlags(classicFeatureFlags, featureFlags);
+            const featureFlags: ConfigurationSetting[] = await this.#loadFeatureFlags();
+            const enhancedFeatureFlags: FeatureFlag[] = await this.#loadEnhancedFeatureFlags();
+            await this.#setFeatureFlags(featureFlags, enhancedFeatureFlags);
         }
 
         this.#ffRefreshTimer!.reset();
@@ -850,11 +850,11 @@ export class AzureAppConfigurationImpl implements AzureAppConfiguration {
     }
 
     /**
-     * Checks whether the feature flag collection from the dedicated feature flag endpoint has changed.
-     * @param selectors - The @see PagedSettingsWatcher of the feature flag collection.
-     * @returns true if the feature flag collection has changed, false otherwise.
+     * Checks whether the enhanced feature flag collection from the dedicated feature flag endpoint has changed.
+     * @param selectors - The @see PagedSettingsWatcher of the enhanced feature flag collection.
+     * @returns true if the enhanced feature flag collection has changed, false otherwise.
      */
-    async #checkFeatureFlagsChange(selectors: PagedSettingsWatcher[]): Promise<boolean> {
+    async #checkEnhancedFeatureFlagsChange(selectors: PagedSettingsWatcher[]): Promise<boolean> {
         const funcToExecute = async (client: IAppConfigurationClient) => {
             for (const selector of selectors) {
                 if (selector.snapshotName) {
@@ -948,7 +948,7 @@ export class AzureAppConfigurationImpl implements AzureAppConfiguration {
         return await this.#executeWithFailoverPolicy(funcToExecute);
     }
 
-    async #listFeatureFlags(listOptions: ListFeatureFlagsOptions): Promise<{ items: FeatureFlag[]; pageWatchers: SettingWatcher[] }> {
+    async #listEnhancedFeatureFlags(listOptions: ListFeatureFlagsOptions): Promise<{ items: FeatureFlag[]; pageWatchers: SettingWatcher[] }> {
         const funcToExecute = async (client: IAppConfigurationClient) => {
             const pageWatchers: SettingWatcher[] = [];
             const pageIterator = client.listFeatureFlags(
@@ -1099,7 +1099,7 @@ export class AzureAppConfigurationImpl implements AzureAppConfiguration {
         return key;
     }
 
-    async #parseClassicFeatureFlag(setting: ConfigurationSetting<string>): Promise<any> {
+    async #parseFeatureFlag(setting: ConfigurationSetting<string>): Promise<any> {
         const rawFlag = setting.value;
         if (rawFlag === undefined) {
             throw new ArgumentError(ErrorMessages.CONFIGURATION_SETTING_VALUE_UNDEFINED);
@@ -1117,7 +1117,7 @@ export class AzureAppConfigurationImpl implements AzureAppConfiguration {
         return featureFlag;
     }
 
-    async #parseFeatureFlag(featureFlag: FeatureFlag): Promise<any> {
+    async #parseEnhancedFeatureFlag(featureFlag: FeatureFlag): Promise<any> {
         const parsedFeatureFlag = convertToMicrosoftSchema(featureFlag);
 
         let featureFlagReference = `${this.#clientManager.endpoint.origin}/ff/${featureFlagPrefix}${featureFlag.name}`;
@@ -1365,7 +1365,7 @@ function getPageWatchers(selectors?: SettingSelector[]): PagedSettingsWatcher[]
     return getValidSettingSelectors(selectors);
 }
 
-function getClassicFeatureFlagPageWatchers(selectors?: SettingSelector[]): PagedSettingsWatcher[] {
+function getFeatureFlagPageWatchers(selectors?: SettingSelector[]): PagedSettingsWatcher[] {
     if (selectors === undefined || selectors.length === 0) {
         // Default selector: key/name: *, label: \0
         return [{ keyFilter: `${featureFlagPrefix}${KeyFilter.Any}`, labelFilter: LabelFilter.Null }];
diff --git a/test/featureFlag.test.ts b/test/featureFlag.test.ts
@@ -6,7 +6,7 @@ import * as chai from "chai";
 import chaiAsPromised from "chai-as-promised";
 import { featureFlagContentType } from "@azure/app-configuration";
 import { load } from "../src/index.js";
-import { mockAppConfigurationClientGetSnapshot, mockAppConfigurationClientListConfigurationSettingsForSnapshot, createMockedConnectionString, createMockedEndpoint, createMockedFeatureFlag, createMockedNewFeatureFlag, createMockedKeyValue, mockAppConfigurationClientListConfigurationSettings, restoreMocks, sleepInMs } from "./utils/testHelper.js";
+import { mockAppConfigurationClientGetSnapshot, mockAppConfigurationClientListConfigurationSettingsForSnapshot, createMockedConnectionString, createMockedEndpoint, createMockedFeatureFlag, createMockedEnhancedFeatureFlag, createMockedKeyValue, mockAppConfigurationClientListConfigurationSettings, restoreMocks, sleepInMs } from "./utils/testHelper.js";
 chai.use(chaiAsPromised);
 const expect = chai.expect;
 
@@ -501,17 +501,17 @@ describe("feature flags", function () {
     });
 });
 
-describe("feature flags from the new endpoint", function () {
+describe("enhanced feature flags", function () {
 
     afterEach(() => {
         restoreMocks();
     });
 
     it("should load feature flags from the dedicated feature flag endpoint", async () => {
-        // no classic feature flags; two feature flags returned by the new endpoint
+        // no feature flags; two enhanced feature flags returned by the dedicated endpoint
         mockAppConfigurationClientListConfigurationSettings([[]], undefined, [[
-            createMockedNewFeatureFlag("NewAlpha", { enabled: true }),
-            createMockedNewFeatureFlag("NewBeta", { enabled: false })
+            createMockedEnhancedFeatureFlag("NewAlpha", { enabled: true }),
+            createMockedEnhancedFeatureFlag("NewBeta", { enabled: false })
         ]]);
 
         const settings = await load(createMockedConnectionString(), {
@@ -524,30 +524,30 @@ describe("feature flags from the new endpoint", function () {
         expect(featureFlags.find(ff => ff.id === "NewBeta").enabled).equals(false);
     });
 
-    it("should let a new feature flag supersede a classic feature flag with the same name", async () => {
-        // classic "Shared" is enabled and "ClassicOnly" exists; the new endpoint returns "Shared" disabled
-        const classicFeatureFlags = [
+    it("should let an enhanced feature flag supersede a feature flag with the same name", async () => {
+        // "Shared" is enabled and "ClassicOnly" exists; the dedicated endpoint returns "Shared" disabled
+        const featureFlagSettings = [
             createMockedFeatureFlag("Shared", { enabled: true }),
             createMockedFeatureFlag("ClassicOnly", { enabled: true })
         ];
-        mockAppConfigurationClientListConfigurationSettings([classicFeatureFlags], undefined, [[
-            createMockedNewFeatureFlag("Shared", { enabled: false })
+        mockAppConfigurationClientListConfigurationSettings([featureFlagSettings], undefined, [[
+            createMockedEnhancedFeatureFlag("Shared", { enabled: false })
         ]]);
 
         const settings = await load(createMockedConnectionString(), {
             featureFlagOptions: { enabled: true }
         });
 
         const featureFlags = settings.get<any>("feature_management").feature_flags as any[];
-        // "Shared" appears once (from the new endpoint, disabled); "ClassicOnly" remains
+        // "Shared" appears once (from the dedicated endpoint, disabled); "ClassicOnly" remains
         expect(featureFlags.length).equals(2);
         expect(featureFlags.filter(ff => ff.id === "Shared").length).equals(1);
         expect(featureFlags.find(ff => ff.id === "Shared").enabled).equals(false);
         expect(featureFlags.find(ff => ff.id === "ClassicOnly").enabled).equals(true);
     });
 
-    it("should convert a new feature flag into the feature management schema", async () => {
-        const newFeatureFlag = createMockedNewFeatureFlag("Variant", {
+    it("should convert an enhanced feature flag into the feature management schema", async () => {
+        const enhancedFeatureFlag = createMockedEnhancedFeatureFlag("Variant", {
             conditions: {
                 requirementType: "All",
                 filters: [{ name: "Microsoft.TimeWindow", parameters: { Start: "Mon, 01 Jan 2024 00:00:00 GMT" } }]
@@ -564,7 +564,7 @@ describe("feature flags from the new endpoint", function () {
             },
             telemetry: { enabled: true }
         });
-        mockAppConfigurationClientListConfigurationSettings([[]], undefined, [[newFeatureFlag]]);
+        mockAppConfigurationClientListConfigurationSettings([[]], undefined, [[enhancedFeatureFlag]]);
 
         const settings = await load(createMockedConnectionString(), {
             featureFlagOptions: { enabled: true }
@@ -586,9 +586,9 @@ describe("feature flags from the new endpoint", function () {
         expect(featureFlag.telemetry.metadata.AllocationId).not.undefined;
     });
 
-    it("should refresh feature flags when the new endpoint changes", async () => {
+    it("should refresh feature flags when the dedicated endpoint changes", async () => {
         mockAppConfigurationClientListConfigurationSettings([[]], undefined, [[
-            createMockedNewFeatureFlag("NewFlag", { enabled: true })
+            createMockedEnhancedFeatureFlag("NewFlag", { enabled: true })
         ]]);
 
         const settings = await load(createMockedConnectionString(), {
@@ -601,10 +601,10 @@ describe("feature flags from the new endpoint", function () {
         let featureFlag = (settings.get<any>("feature_management").feature_flags as any[]).find(ff => ff.id === "NewFlag");
         expect(featureFlag.enabled).equals(true);
 
-        // the feature flag on the new endpoint changes
+        // the enhanced feature flag on the dedicated endpoint changes
         restoreMocks();
         mockAppConfigurationClientListConfigurationSettings([[]], undefined, [[
-            createMockedNewFeatureFlag("NewFlag", { enabled: false })
+            createMockedEnhancedFeatureFlag("NewFlag", { enabled: false })
         ]]);
 
         await sleepInMs(1000 + 1);
diff --git a/test/loadBalance.test.ts b/test/loadBalance.test.ts
@@ -51,13 +51,13 @@ describe("load balance", function () {
                 }
             }
         });
-        // one request for key values, one for classic feature flags, one for the new feature flag endpoint
+        // one request for key values, one for feature flags, one for the dedicated feature flag endpoint
         expect(clientRequestCounter_1.count).eq(2);
         expect(clientRequestCounter_2.count).eq(1);
 
         await sleepInMs(2 * 1000 + 1);
         await settings.refresh();
-        // refresh: one request to check classic feature flags, one to check the new feature flag endpoint
+        // refresh: one request to check feature flags, one to check the dedicated feature flag endpoint
         expect(clientRequestCounter_1.count).eq(3);
         expect(clientRequestCounter_2.count).eq(2);
 
@@ -88,13 +88,13 @@ describe("load balance", function () {
                 }
             }
         });
-        // one request for key values, one for classic feature flags, one for the new feature flag endpoint
+        // one request for key values, one for feature flags, one for the dedicated feature flag endpoint
         expect(clientRequestCounter_1.count).eq(3);
         expect(clientRequestCounter_2.count).eq(0);
 
         await sleepInMs(2 * 1000 + 1);
         await settings.refresh();
-        // refresh: check classic feature flags + check the new feature flag endpoint, all to the first client
+        // refresh: check feature flags + check the dedicated feature flag endpoint, all to the first client
         expect(clientRequestCounter_1.count).eq(5);
         expect(clientRequestCounter_2.count).eq(0);
     });
diff --git a/test/utils/testHelper.ts b/test/utils/testHelper.ts
