resolve comments

Author: linglingye001

src/appConfigurationImpl.ts

@@ -841,6 +841,10 @@ export class AzureAppConfigurationImpl implements AzureAppConfiguration {
                     }
                     i++;
                 }
+
+                if (i < pageWatchers.length) {
+                    return true;
+                }
             }
             return false;
         };
@@ -887,7 +891,7 @@ export class AzureAppConfigurationImpl implements AzureAppConfiguration {
                     const lastServerResponseTime = pageWatchers[i].lastServerResponseTime;
                     let isResponseFresh = false;
                     if (lastServerResponseTime !== undefined) {
-                        isResponseFresh = serverResponseTime > lastServerResponseTime;
+                        isResponseFresh = serverResponseTime >= lastServerResponseTime;
                     }
                     if (isResponseFresh &&
                         getStatusCode(page._response.status) === 200 && // conditional request returns 304 if not changed
@@ -1370,14 +1374,14 @@ function getFeatureFlagPageWatchers(selectors?: SettingSelector[]): PagedSetting
         // Default selector: key/name: *, label: \0
         return [{ keyFilter: `${featureFlagPrefix}${KeyFilter.Any}`, labelFilter: LabelFilter.Null }];
     }
-    // Deep clone so the caller's option objects are never mutated.
-    const clonedSelectors = structuredClone(selectors);
-    clonedSelectors.forEach(selector => {
-        if (selector.keyFilter) {
-            selector.keyFilter = `${featureFlagPrefix}${selector.keyFilter}`;
-        }
-    });
-    return getValidSettingSelectors(clonedSelectors);
+    // Create prefixed copies because the original selectors are also used as unprefixed selectors for enhanced feature flags.
+    const prefixedSelectors = selectors.map(selector => ({
+        ...selector,
+        keyFilter: selector.keyFilter
+            ? `${featureFlagPrefix}${selector.keyFilter}`
+             : selector.keyFilter
+    }));
+    return getValidSettingSelectors(prefixedSelectors);
 }
 
 function validateTagFilters(tagFilters: string[]): void {

src/featureManagement/featureFlagConverter.ts

@@ -1,57 +1,62 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
 
-import { FeatureFlag } from "@azure/app-configuration";
+import type { FeatureFlag as AzAppConfigFeatureFlag } from "@azure/app-configuration";
+import type {
+    FeatureFilter,
+    FeatureFlag,
+    FeatureFlagAllocation,
+    FeatureFlagTelemetry,
+    FeatureFlagVariant
+} from "./featureFlags.js";
 
 /**
  * Converts @see FeatureFlag into the
  * Microsoft Feature Flag schema object used within the `feature_management.feature_flags`
  * array. This mirrors the shape produced by parsing a classic feature flag key-value, so that downstream
  * feature management parsing and the provider's telemetry/tracing logic are unchanged.
  */
-export function convert(featureFlag: FeatureFlag): any {
-    const result: any = {
+export function convert(featureFlag: AzAppConfigFeatureFlag): FeatureFlag {
+    const result: FeatureFlag = {
         id: featureFlag.name,
-        enabled: featureFlag.enabled
+        enabled: featureFlag.enabled,
+        conditions: {
+            client_filters: (featureFlag.conditions?.filters ?? []).map(filter => {
+                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]));
+                }
+                return clientFilter;
+            })
+        }
     };
 
     if (featureFlag.description != null) {
         result.description = featureFlag.description;
     }
 
-    // conditions: filters -> client_filters, requirementType -> requirement_type
-    const conditions: any = {
-        client_filters: (featureFlag.conditions?.filters ?? []).map(filter => {
-            const clientFilter: any = { name: filter.name };
-            if (filter.parameters != null) {
-                clientFilter.parameters = Object.fromEntries(
-                    Object.entries(filter.parameters).map(([name, value]) => [name, JSON.parse(value)]));
-            }
-            return clientFilter;
-        })
-    };
     if (featureFlag.conditions?.requirementType != null) {
-        conditions.requirement_type = featureFlag.conditions.requirementType;
+        result.conditions.requirement_type = featureFlag.conditions.requirementType;
     }
-    result.conditions = conditions;
 
     // variants: value -> configuration_value, statusOverride -> status_override
     if (featureFlag.variants != null) {
         result.variants = featureFlag.variants.map(variant => {
-            const result_variant: any = { name: variant.name };
+            const resultVariant: FeatureFlagVariant = { name: variant.name };
             if (variant.value !== undefined) {
-                result_variant.configuration_value = variant.value;
+                resultVariant.configuration_value = variant.value;
             }
             if (variant.statusOverride != null) {
-                result_variant.status_override = variant.statusOverride;
+                resultVariant.status_override = variant.statusOverride;
             }
-            return result_variant;
+            return resultVariant;
         });
     }
 
     // allocation: camelCase -> snake_case
     if (featureFlag.allocation != null) {
-        const allocation: any = {};
+        const allocation: FeatureFlagAllocation = {};
         const sourceAllocation = featureFlag.allocation;
         if (sourceAllocation.defaultWhenDisabled != null) {
             allocation.default_when_disabled = sourceAllocation.defaultWhenDisabled;
@@ -76,7 +81,7 @@ export function convert(featureFlag: FeatureFlag): any {
 
     // telemetry: metadata is (re)populated later by the provider with ETag/FeatureFlagReference/AllocationId
     if (featureFlag.telemetry != null) {
-        const telemetry: any = { enabled: featureFlag.telemetry.enabled };
+        const telemetry: FeatureFlagTelemetry = { enabled: featureFlag.telemetry.enabled };
         if (featureFlag.telemetry.metadata != null) {
             telemetry.metadata = featureFlag.telemetry.metadata;
         }

src/featureManagement/featureFlags.ts

@@ -0,0 +1,54 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+import type {
+    FeatureFlag as AzAppConfigFeatureFlag,
+    FeatureFlagAllocation as AzAppConfigFeatureFlagAllocation,
+    FeatureFlagConditions as AzAppConfigFeatureFlagConditions,
+    FeatureFilter as AzAppConfigFeatureFilter,
+    FeatureFlagTelemetryConfiguration as AzAppConfigFeatureFlagTelemetryConfiguration,
+    FeatureFlagVariantDefinition as AzAppConfigFeatureFlagVariantDefinition,
+    GroupAllocation as AzAppConfigGroupAllocation,
+    PercentileAllocation as AzAppConfigPercentileAllocation,
+    UserAllocation as AzAppConfigUserAllocation
+} from "@azure/app-configuration";
+
+export interface FeatureFilter {
+    name: AzAppConfigFeatureFilter["name"];
+    parameters?: Record<string, unknown>;
+}
+
+export interface FeatureFlagConditions {
+    client_filters: FeatureFilter[];
+    requirement_type?: AzAppConfigFeatureFlagConditions["requirementType"];
+}
+
+export interface FeatureFlagVariant {
+    name: AzAppConfigFeatureFlagVariantDefinition["name"];
+    configuration_value?: AzAppConfigFeatureFlagVariantDefinition["value"];
+    status_override?: AzAppConfigFeatureFlagVariantDefinition["statusOverride"];
+}
+
+export interface FeatureFlagAllocation {
+    default_when_disabled?: AzAppConfigFeatureFlagAllocation["defaultWhenDisabled"];
+    default_when_enabled?: AzAppConfigFeatureFlagAllocation["defaultWhenEnabled"];
+    percentile?: AzAppConfigPercentileAllocation[];
+    user?: AzAppConfigUserAllocation[];
+    group?: AzAppConfigGroupAllocation[];
+    seed?: AzAppConfigFeatureFlagAllocation["seed"];
+}
+
+export interface FeatureFlagTelemetry {
+    enabled: AzAppConfigFeatureFlagTelemetryConfiguration["enabled"];
+    metadata?: AzAppConfigFeatureFlagTelemetryConfiguration["metadata"];
+}
+
+export interface FeatureFlag {
+    id: AzAppConfigFeatureFlag["name"];
+    enabled: AzAppConfigFeatureFlag["enabled"];
+    description?: AzAppConfigFeatureFlag["description"];
+    conditions: FeatureFlagConditions;
+    variants?: FeatureFlagVariant[];
+    allocation?: FeatureFlagAllocation;
+    telemetry?: FeatureFlagTelemetry;
+}