@microsoft/feature-management 2.0.0-preview.3 → 2.0.1

package/dist/umd/index.js

@@ -141,7 +141,7 @@
         name = "Microsoft.Targeting";
         async evaluate(context, appContext) {
             const { featureName, parameters } = context;
-            TargetingFilter.#validateParameters(parameters);
+            TargetingFilter.#validateParameters(featureName, parameters);
             if (appContext === undefined) {
                 throw new Error("The app context is required for targeting filter.");
             }
@@ -184,15 +184,15 @@
             const hint = featureName;
             return isTargetedPercentile(appContext?.userId, hint, 0, parameters.Audience.DefaultRolloutPercentage);
         }
-        static #validateParameters(parameters) {
+        static #validateParameters(featureName, parameters) {
             if (parameters.Audience.DefaultRolloutPercentage < 0 || parameters.Audience.DefaultRolloutPercentage > 100) {
-                throw new Error("Audience.DefaultRolloutPercentage must be a number between 0 and 100.");
+                throw new Error(`Invalid feature flag: ${featureName}. Audience.DefaultRolloutPercentage must be a number between 0 and 100.`);
             }
             // validate RolloutPercentage for each group
             if (parameters.Audience.Groups !== undefined) {
                 for (const group of parameters.Audience.Groups) {
                     if (group.RolloutPercentage < 0 || group.RolloutPercentage > 100) {
-                        throw new Error(`RolloutPercentage of group ${group.Name} must be a number between 0 and 100.`);
+                        throw new Error(`Invalid feature flag: ${featureName}. RolloutPercentage of group ${group.Name} must be a number between 0 and 100.`);
                     }
                 }
             }
@@ -471,157 +471,157 @@
             throw new TypeError("Feature flag 'id' must be a string.");
         }
         if (featureFlag.enabled !== undefined && typeof featureFlag.enabled !== "boolean") {
-            throw new TypeError("Feature flag 'enabled' must be a boolean.");
+            throw new TypeError(`Invalid feature flag: ${featureFlag.id}. Feature flag 'enabled' must be a boolean.`);
         }
         if (featureFlag.conditions !== undefined) {
-            validateFeatureEnablementConditions(featureFlag.conditions);
+            validateFeatureEnablementConditions(featureFlag.id, featureFlag.conditions);
         }
         if (featureFlag.variants !== undefined) {
-            validateVariants(featureFlag.variants);
+            validateVariants(featureFlag.id, featureFlag.variants);
         }
         if (featureFlag.allocation !== undefined) {
-            validateVariantAllocation(featureFlag.allocation);
+            validateVariantAllocation(featureFlag.id, featureFlag.allocation);
         }
         if (featureFlag.telemetry !== undefined) {
-            validateTelemetryOptions(featureFlag.telemetry);
+            validateTelemetryOptions(featureFlag.id, featureFlag.telemetry);
         }
     }
-    function validateFeatureEnablementConditions(conditions) {
+    function validateFeatureEnablementConditions(id, conditions) {
         if (typeof conditions !== "object") {
-            throw new TypeError("Feature flag 'conditions' must be an object.");
+            throw new TypeError(`Invalid feature flag: ${id}. Feature flag 'conditions' must be an object.`);
         }
         if (conditions.requirement_type !== undefined && conditions.requirement_type !== "Any" && conditions.requirement_type !== "All") {
-            throw new TypeError("'requirement_type' must be 'Any' or 'All'.");
+            throw new TypeError(`Invalid feature flag: ${id}. 'requirement_type' must be 'Any' or 'All'.`);
         }
         if (conditions.client_filters !== undefined) {
-            validateClientFilters(conditions.client_filters);
+            validateClientFilters(id, conditions.client_filters);
         }
     }
-    function validateClientFilters(client_filters) {
+    function validateClientFilters(id, client_filters) {
         if (!Array.isArray(client_filters)) {
-            throw new TypeError("Feature flag conditions 'client_filters' must be an array.");
+            throw new TypeError(`Invalid feature flag: ${id}. Feature flag conditions 'client_filters' must be an array.`);
         }
         for (const filter of client_filters) {
             if (typeof filter.name !== "string") {
-                throw new TypeError("Client filter 'name' must be a string.");
+                throw new TypeError(`Invalid feature flag: ${id}. Client filter 'name' must be a string.`);
             }
             if (filter.parameters !== undefined && typeof filter.parameters !== "object") {
-                throw new TypeError("Client filter 'parameters' must be an object.");
+                throw new TypeError(`Invalid feature flag: ${id}. Client filter 'parameters' must be an object.`);
             }
         }
     }
-    function validateVariants(variants) {
+    function validateVariants(id, variants) {
         if (!Array.isArray(variants)) {
-            throw new TypeError("Feature flag 'variants' must be an array.");
+            throw new TypeError(`Invalid feature flag: ${id}. Feature flag 'variants' must be an array.`);
         }
         for (const variant of variants) {
             if (typeof variant.name !== "string") {
-                throw new TypeError("Variant 'name' must be a string.");
+                throw new TypeError(`Invalid feature flag: ${id}. Variant 'name' must be a string.`);
             }
             // skip configuration_value validation as it accepts any type
             if (variant.status_override !== undefined && typeof variant.status_override !== "string") {
-                throw new TypeError("Variant 'status_override' must be a string.");
+                throw new TypeError(`Invalid feature flag: ${id}. Variant 'status_override' must be a string.`);
             }
             if (variant.status_override !== undefined && variant.status_override !== "None" && variant.status_override !== "Enabled" && variant.status_override !== "Disabled") {
-                throw new TypeError("Variant 'status_override' must be 'None', 'Enabled', or 'Disabled'.");
+                throw new TypeError(`Invalid feature flag: ${id}. Variant 'status_override' must be 'None', 'Enabled', or 'Disabled'.`);
             }
         }
     }
-    function validateVariantAllocation(allocation) {
+    function validateVariantAllocation(id, allocation) {
         if (typeof allocation !== "object") {
-            throw new TypeError("Variant 'allocation' must be an object.");
+            throw new TypeError(`Invalid feature flag: ${id}. Variant 'allocation' must be an object.`);
         }
         if (allocation.default_when_disabled !== undefined && typeof allocation.default_when_disabled !== "string") {
-            throw new TypeError("Variant allocation 'default_when_disabled' must be a string.");
+            throw new TypeError(`Invalid feature flag: ${id}. Variant allocation 'default_when_disabled' must be a string.`);
         }
         if (allocation.default_when_enabled !== undefined && typeof allocation.default_when_enabled !== "string") {
-            throw new TypeError("Variant allocation 'default_when_enabled' must be a string.");
+            throw new TypeError(`Invalid feature flag: ${id}. Variant allocation 'default_when_enabled' must be a string.`);
         }
         if (allocation.user !== undefined) {
-            validateUserVariantAllocation(allocation.user);
+            validateUserVariantAllocation(id, allocation.user);
         }
         if (allocation.group !== undefined) {
-            validateGroupVariantAllocation(allocation.group);
+            validateGroupVariantAllocation(id, allocation.group);
         }
         if (allocation.percentile !== undefined) {
-            validatePercentileVariantAllocation(allocation.percentile);
+            validatePercentileVariantAllocation(id, allocation.percentile);
         }
         if (allocation.seed !== undefined && typeof allocation.seed !== "string") {
-            throw new TypeError("Variant allocation 'seed' must be a string.");
+            throw new TypeError(`Invalid feature flag: ${id}. Variant allocation 'seed' must be a string.`);
         }
     }
-    function validateUserVariantAllocation(UserAllocations) {
+    function validateUserVariantAllocation(id, UserAllocations) {
         if (!Array.isArray(UserAllocations)) {
-            throw new TypeError("Variant 'user' allocation must be an array.");
+            throw new TypeError(`Invalid feature flag: ${id}. Variant 'user' allocation must be an array.`);
         }
         for (const allocation of UserAllocations) {
             if (typeof allocation !== "object") {
-                throw new TypeError("Elements in variant 'user' allocation must be an object.");
+                throw new TypeError(`Invalid feature flag: ${id}. Elements in variant 'user' allocation must be an object.`);
             }
             if (typeof allocation.variant !== "string") {
-                throw new TypeError("User allocation 'variant' must be a string.");
+                throw new TypeError(`Invalid feature flag: ${id}. User allocation 'variant' must be a string.`);
             }
             if (!Array.isArray(allocation.users)) {
-                throw new TypeError("User allocation 'users' must be an array.");
+                throw new TypeError(`Invalid feature flag: ${id}. User allocation 'users' must be an array.`);
             }
             for (const user of allocation.users) {
                 if (typeof user !== "string") {
-                    throw new TypeError("Elements in user allocation 'users' must be strings.");
+                    throw new TypeError(`Invalid feature flag: ${id}. Elements in user allocation 'users' must be strings.`);
                 }
             }
         }
     }
-    function validateGroupVariantAllocation(groupAllocations) {
+    function validateGroupVariantAllocation(id, groupAllocations) {
         if (!Array.isArray(groupAllocations)) {
-            throw new TypeError("Variant 'group' allocation must be an array.");
+            throw new TypeError(`Invalid feature flag: ${id}. Variant 'group' allocation must be an array.`);
         }
         for (const allocation of groupAllocations) {
             if (typeof allocation !== "object") {
-                throw new TypeError("Elements in variant 'group' allocation must be an object.");
+                throw new TypeError(`Invalid feature flag: ${id}. Elements in variant 'group' allocation must be an object.`);
             }
             if (typeof allocation.variant !== "string") {
-                throw new TypeError("Group allocation 'variant' must be a string.");
+                throw new TypeError(`Invalid feature flag: ${id}. Group allocation 'variant' must be a string.`);
             }
             if (!Array.isArray(allocation.groups)) {
-                throw new TypeError("Group allocation 'groups' must be an array.");
+                throw new TypeError(`Invalid feature flag: ${id}. Group allocation 'groups' must be an array.`);
             }
             for (const group of allocation.groups) {
                 if (typeof group !== "string") {
-                    throw new TypeError("Elements in group allocation 'groups' must be strings.");
+                    throw new TypeError(`Invalid feature flag: ${id}. Elements in group allocation 'groups' must be strings.`);
                 }
             }
         }
     }
-    function validatePercentileVariantAllocation(percentileAllocations) {
+    function validatePercentileVariantAllocation(id, percentileAllocations) {
         if (!Array.isArray(percentileAllocations)) {
-            throw new TypeError("Variant 'percentile' allocation must be an array.");
+            throw new TypeError(`Invalid feature flag: ${id}. Variant 'percentile' allocation must be an array.`);
         }
         for (const allocation of percentileAllocations) {
             if (typeof allocation !== "object") {
-                throw new TypeError("Elements in variant 'percentile' allocation must be an object.");
+                throw new TypeError(`Invalid feature flag: ${id}. Elements in variant 'percentile' allocation must be an object.`);
             }
             if (typeof allocation.variant !== "string") {
-                throw new TypeError("Percentile allocation 'variant' must be a string.");
+                throw new TypeError(`Invalid feature flag: ${id}. Percentile allocation 'variant' must be a string.`);
             }
             if (typeof allocation.from !== "number" || allocation.from < 0 || allocation.from > 100) {
-                throw new TypeError("Percentile allocation 'from' must be a number between 0 and 100.");
+                throw new TypeError(`Invalid feature flag: ${id}. Percentile allocation 'from' must be a number between 0 and 100.`);
             }
             if (typeof allocation.to !== "number" || allocation.to < 0 || allocation.to > 100) {
-                throw new TypeError("Percentile allocation 'to' must be a number between 0 and 100.");
+                throw new TypeError(`Invalid feature flag: ${id}. Percentile allocation 'to' must be a number between 0 and 100.`);
             }
         }
     }
     // #endregion
     // #region Telemetry
-    function validateTelemetryOptions(telemetry) {
+    function validateTelemetryOptions(id, telemetry) {
         if (typeof telemetry !== "object") {
-            throw new TypeError("Feature flag 'telemetry' must be an object.");
+            throw new TypeError(`Invalid feature flag: ${id}. Feature flag 'telemetry' must be an object.`);
         }
         if (telemetry.enabled !== undefined && typeof telemetry.enabled !== "boolean") {
-            throw new TypeError("Telemetry 'enabled' must be a boolean.");
+            throw new TypeError(`Invalid feature flag: ${id}. Telemetry 'enabled' must be a boolean.`);
         }
         if (telemetry.metadata !== undefined && typeof telemetry.metadata !== "object") {
-            throw new TypeError("Telemetry 'metadata' must be an object.");
+            throw new TypeError(`Invalid feature flag: ${id}. Telemetry 'metadata' must be an object.`);
         }
     }
     // #endregion
@@ -644,9 +644,11 @@
         }
         async getFeatureFlags() {
             const featureConfig = this.#configuration.get(FEATURE_MANAGEMENT_KEY);
-            const featureFlag = featureConfig?.[FEATURE_FLAGS_KEY] ?? [];
-            validateFeatureFlag(featureFlag);
-            return featureFlag;
+            const featureFlags = featureConfig?.[FEATURE_FLAGS_KEY] ?? [];
+            featureFlags.forEach(featureFlag => {
+                validateFeatureFlag(featureFlag);
+            });
+            return featureFlags;
         }
     }
     /**
@@ -664,15 +666,17 @@
             return featureFlag;
         }
         async getFeatureFlags() {
-            const featureFlag = this.#configuration[FEATURE_MANAGEMENT_KEY]?.[FEATURE_FLAGS_KEY] ?? [];
-            validateFeatureFlag(featureFlag);
-            return featureFlag;
+            const featureFlags = this.#configuration[FEATURE_MANAGEMENT_KEY]?.[FEATURE_FLAGS_KEY] ?? [];
+            featureFlags.forEach(featureFlag => {
+                validateFeatureFlag(featureFlag);
+            });
+            return featureFlags;
         }
     }
 
     // Copyright (c) Microsoft Corporation.
     // Licensed under the MIT license.
-    const VERSION$1 = "2.0.0-preview.3";
+    const VERSION$1 = "2.0.1";
     const EVALUATION_EVENT_VERSION = "1.0.0";
 
     // Copyright (c) Microsoft Corporation.
@@ -683,8 +687,6 @@
     const TARGETING_ID = "TargetingId";
     const VARIANT = "Variant";
     const VARIANT_ASSIGNMENT_REASON = "VariantAssignmentReason";
-    const DEFAULT_WHEN_ENABLED = "DefaultWhenEnabled";
-    const VARIANT_ASSIGNMENT_PERCENTAGE = "VariantAssignmentPercentage";
     function createFeatureEvaluationEventProperties(result) {
         if (result.feature === undefined) {
             return undefined;
@@ -698,29 +700,6 @@
             [VARIANT]: result.variant ? result.variant.name : "",
             [VARIANT_ASSIGNMENT_REASON]: result.variantAssignmentReason,
         };
-        if (result.feature.allocation?.default_when_enabled) {
-            eventProperties[DEFAULT_WHEN_ENABLED] = result.feature.allocation.default_when_enabled;
-        }
-        if (result.variantAssignmentReason === exports.VariantAssignmentReason.DefaultWhenEnabled) {
-            let percentileAllocationPercentage = 0;
-            if (result.variant !== undefined && result.feature.allocation !== undefined && result.feature.allocation.percentile !== undefined) {
-                for (const percentile of result.feature.allocation.percentile) {
-                    percentileAllocationPercentage += percentile.to - percentile.from;
-                }
-            }
-            eventProperties[VARIANT_ASSIGNMENT_PERCENTAGE] = (100 - percentileAllocationPercentage).toString();
-        }
-        else if (result.variantAssignmentReason === exports.VariantAssignmentReason.Percentile) {
-            let percentileAllocationPercentage = 0;
-            if (result.variant !== undefined && result.feature.allocation !== undefined && result.feature.allocation.percentile !== undefined) {
-                for (const percentile of result.feature.allocation.percentile) {
-                    if (percentile.variant === result.variant.name) {
-                        percentileAllocationPercentage += percentile.to - percentile.from;
-                    }
-                }
-            }
-            eventProperties[VARIANT_ASSIGNMENT_PERCENTAGE] = percentileAllocationPercentage.toString();
-        }
         const metadata = result.feature.telemetry?.metadata;
         if (metadata) {
             for (const key in metadata) {