enhanced ff: remove prefix in feature flag reference and update client fitler parameter/variant value handling

Author: linglingye001

src/appConfigurationImpl.ts

@@ -1124,7 +1124,7 @@ export class AzureAppConfigurationImpl implements AzureAppConfiguration {
     async #parseEnhancedFeatureFlag(featureFlag: FeatureFlag): Promise<any> {
         const parsedFeatureFlag = convert(featureFlag);
 
-        let featureFlagReference = `${this.#clientManager.endpoint.origin}/ff/${featureFlagPrefix}${featureFlag.name}`;
+        let featureFlagReference = `${this.#clientManager.endpoint.origin}/ff/${featureFlag.name}`;
         if (featureFlag.label && featureFlag.label.trim().length !== 0) {
             featureFlagReference += `?label=${featureFlag.label}`;
         }

src/featureManagement/featureFlagConverter.ts

@@ -9,6 +9,7 @@ import type {
     FeatureFlagTelemetry,
     FeatureFlagVariant
 } from "./featureFlags.js";
+import { isJsonContentType, parseContentType } from "../common/contentType.js";
 
 /**
  * Converts @see FeatureFlag into the
@@ -25,7 +26,7 @@ export function convert(featureFlag: AzAppConfigFeatureFlag): FeatureFlag {
                 const clientFilter: FeatureFilter = { name: filter.name };
                 if (filter.parameters != null) {
                     clientFilter.parameters = Object.fromEntries(
-                        Object.entries(filter.parameters).map(([name, value]): [string, unknown] => [name, JSON.parse(value) as unknown]));
+                        Object.entries(filter.parameters).map(([name, value]) => [name, parseParameterValue(value, featureFlag.name)]));
                 }
                 return clientFilter;
             })
@@ -45,7 +46,9 @@ export function convert(featureFlag: AzAppConfigFeatureFlag): FeatureFlag {
         result.variants = featureFlag.variants.map(variant => {
             const resultVariant: FeatureFlagVariant = { name: variant.name };
             if (variant.value !== undefined) {
-                resultVariant.configuration_value = variant.value;
+                resultVariant.configuration_value = isJsonContentType(parseContentType(variant.contentType))
+                    ? parseJsonValue(variant.value, featureFlag.name)
+                    : variant.value;
             }
             if (variant.statusOverride != null) {
                 resultVariant.status_override = variant.statusOverride;
@@ -90,3 +93,21 @@ export function convert(featureFlag: AzAppConfigFeatureFlag): FeatureFlag {
 
     return result;
 }
+
+function parseParameterValue(value: string, featureFlagName: string): unknown {
+    const trimmedValue = value.trim();
+    if (trimmedValue.length > 0 && (trimmedValue[0] === "{" || trimmedValue[0] === "[")) {
+        return parseJsonValue(value, featureFlagName);
+    }
+
+    return value;
+}
+
+function parseJsonValue(value: string, featureFlagName: string): unknown {
+    try {
+        return JSON.parse(value) as unknown;
+    } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        throw new SyntaxError(`Enhanced feature flag '${featureFlagName}': ${errorMessage}`, { cause: error });
+    }
+}

src/featureManagement/featureFlags.ts

@@ -25,7 +25,7 @@ export interface FeatureFlagConditions {
 
 export interface FeatureFlagVariant {
     name: AzAppConfigFeatureFlagVariantDefinition["name"];
-    configuration_value?: AzAppConfigFeatureFlagVariantDefinition["value"];
+    configuration_value?: unknown;
     status_override?: AzAppConfigFeatureFlagVariantDefinition["statusOverride"];
 }
 

src/requestTracing/utils.ts

@@ -143,6 +143,7 @@ export function requestTracingEnabled(): boolean {
 function usesAnyTracingFeature(requestTracingOptions: RequestTracingOptions): boolean {
     return (requestTracingOptions.appConfigOptions?.loadBalancingEnabled ?? false) ||
         (requestTracingOptions.aiConfigurationTracing?.usesAnyTracingFeature() ?? false) ||
+        requestTracingOptions.useEnhancedFeatureFlag ||
         requestTracingOptions.isAfdUsed;
 }
 

test/featureFlag.test.ts

@@ -6,7 +6,8 @@ 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, createMockedEnhancedFeatureFlag, createMockedKeyValue, mockAppConfigurationClientListConfigurationSettings, mockFeatureFlagClientListFeatureFlags, restoreMocks, sleepInMs } from "./utils/testHelper.js";
+import { convert } from "../src/featureManagement/featureFlagConverter.js";
+import { mockAppConfigurationClientGetSnapshot, mockAppConfigurationClientListConfigurationSettingsForSnapshot, createMockedConnectionString, createMockedEndpoint, createMockedFeatureFlag, createMockedEnhancedFeatureFlag, createMockedKeyValue, mockAppConfigurationClientListConfigurationSettings, mockFeatureFlagClientListFeatureFlags, restoreMocks, sleepInMs, expectEnhancedFeatureFlagJsonError } from "./utils/testHelper.js";
 chai.use(chaiAsPromised);
 const expect = chai.expect;
 
@@ -567,6 +568,7 @@ describe("enhanced feature flags", function () {
                         name: "Microsoft.Targeting",
                         parameters: {
                             Audience: JSON.stringify(audience),
+                            JsonArray: "  [\"one\",\"two\"]  ",
                             PlainText: "not-json",
                             Percentage: "50"
                         }
@@ -583,8 +585,43 @@ describe("enhanced feature flags", function () {
             .find(ff => ff.id === "Targeted");
         const parameters = featureFlag.conditions.client_filters[0].parameters;
         expect(parameters.Audience).deep.equals(audience);
+        expect(parameters.JsonArray).deep.equals(["one", "two"]);
         expect(parameters.PlainText).equals("not-json");
-        expect(parameters.Percentage).equals(50);
+        expect(parameters.Percentage).equals("50");
+    });
+
+    it("should throw for invalid JSON in enhanced feature flag filter parameters", () => {
+        const enhancedFeatureFlag = createMockedEnhancedFeatureFlag("InvalidParameter", {
+            conditions: {
+                filters: [{
+                    name: "CustomFilter",
+                    parameters: { Value: "{not-json}" }
+                }]
+            }
+        });
+
+        expectEnhancedFeatureFlagJsonError(() => convert(enhancedFeatureFlag), "InvalidParameter");
+    });
+
+    it("should parse enhanced feature flag variants based on content type", () => {
+        const enhancedFeatureFlag = createMockedEnhancedFeatureFlag("VariantContentType", {
+            variants: [
+                { name: "Json", value: "{\"color\":\"blue\"}", contentType: "application/json" },
+                { name: "Text", value: "{\"color\":\"blue\"}", contentType: "text/plain" }
+            ]
+        });
+
+        const featureFlag = convert(enhancedFeatureFlag);
+        expect(featureFlag.variants?.[0].configuration_value).deep.equals({ color: "blue" });
+        expect(featureFlag.variants?.[1].configuration_value).equals("{\"color\":\"blue\"}");
+    });
+
+    it("should throw for invalid JSON in an enhanced feature flag variant", () => {
+        const enhancedFeatureFlag = createMockedEnhancedFeatureFlag("InvalidVariant", {
+            variants: [{ name: "Json", value: "{not-json}", contentType: "application/json" }]
+        });
+
+        expectEnhancedFeatureFlagJsonError(() => convert(enhancedFeatureFlag), "InvalidVariant");
     });
 
     it("should let an enhanced feature flag supersede a feature flag with the same name", async () => {
@@ -647,7 +684,7 @@ describe("enhanced feature flags", function () {
         expect(featureFlag.allocation.percentile[0].variant).equals("On");
         // telemetry enabled => metadata populated with the feature flag reference and allocation id
         expect(featureFlag.telemetry.metadata).not.undefined;
-        expect(featureFlag.telemetry.metadata.FeatureFlagReference).contains(".appconfig.featureflag/Variant");
+        expect(featureFlag.telemetry.metadata.FeatureFlagReference).equals(`${createMockedEndpoint()}/ff/Variant`);
         expect(featureFlag.telemetry.metadata.AllocationId).not.undefined;
     });
 

test/utils/testHelper.ts

@@ -2,6 +2,7 @@
 // Licensed under the MIT license.
 
 import * as sinon from "sinon";
+import * as chai from "chai";
 import { AppConfigurationClient as ConfigurationClient, ConfigurationSetting, FeatureFlagClient, featureFlagContentType, secretReferenceContentType } from "@azure/app-configuration";
 import { ClientSecretCredential } from "@azure/identity";
 import { KeyVaultSecret, SecretClient } from "@azure/keyvault-secrets";
@@ -13,6 +14,21 @@ import { AppConfigurationClient } from "../../src/appConfigurationClient.js";
 
 const sleepInMs = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms));
 
+function expectEnhancedFeatureFlagJsonError(action: () => unknown, featureFlagName: string): void {
+    let thrownError: unknown;
+    try {
+        action();
+    } catch (error) {
+        thrownError = error;
+    }
+
+    chai.expect(thrownError).instanceOf(SyntaxError);
+    const syntaxError = thrownError as SyntaxError;
+    chai.expect(syntaxError.message).contains(`Enhanced feature flag '${featureFlagName}':`);
+    chai.expect(syntaxError.cause).instanceOf(SyntaxError);
+    chai.expect(syntaxError.message).contains((syntaxError.cause as SyntaxError).message);
+}
+
 // Async, browser-safe SHA-256 using native crypto.subtle when available; falls back to tiny FNV-1a for Node without subtle.
 async function _sha256(input: string): Promise<string> {
     let crypto;
@@ -589,6 +605,7 @@ export {
     createMockedFeatureFlag,
     createMockedEnhancedFeatureFlag,
     createMockedSnapshotReference,
+    expectEnhancedFeatureFlagJsonError,
 
     sleepInMs,
     HttpRequestHeadersPolicy