feat: dependent features

src/client.ts

@@ -19,13 +19,16 @@ export default class UnleashClient extends EventEmitter {
 
   private strategies: Strategy[];
 
-  private warned: BooleanMap;
+  private warnedStrategies: BooleanMap;
+
+  private warnedDependencies: BooleanMap;
 
   constructor(repository: RepositoryInterface, strategies: Strategy[]) {
     super();
     this.repository = repository;
     this.strategies = strategies || [];
-    this.warned = {};
+    this.warnedStrategies = {};
+    this.warnedDependencies = {};
 
     this.strategies.forEach((strategy: Strategy) => {
       if (
@@ -43,9 +46,11 @@ export default class UnleashClient extends EventEmitter {
     return this.strategies.find((strategy: Strategy): boolean => strategy.name === name);
   }
 
-  warnOnce(missingStrategy: string, name: string, strategies: StrategyTransportInterface[]) {
-    if (!this.warned[missingStrategy + name]) {
-      this.warned[missingStrategy + name] = true;
+  warnStrategyOnce(missingStrategy: string,
+                   name: string,
+                   strategies: StrategyTransportInterface[]) {
+    if (!this.warnedStrategies[missingStrategy + name]) {
+      this.warnedStrategies[missingStrategy + name] = true;
       this.emit(
         UnleashEvents.Warn,
         `Missing strategy "${missingStrategy}" for toggle "${name}". Ensure that "${strategies
@@ -55,9 +60,54 @@ export default class UnleashClient extends EventEmitter {
     }
   }
 
+  warnDependencyOnce(missingDependency: string, name: string) {
+    if (!this.warnedDependencies[missingDependency + name]) {
+      this.warnedDependencies[missingDependency + name] = true;
+      this.emit(
+        UnleashEvents.Warn,
+        `Missing dependency "${missingDependency}" for toggle "${name}"`,
+      );
+    }
+  }
+
+  isParentDependencySatisfied(feature: FeatureInterface | undefined, context: Context) {
+    if (!feature?.dependencies?.length) {
+      return true;
+    }
+
+    return feature.dependencies.every(parent => {
+      const parentToggle = this.repository.getToggle(parent.feature);
+
+      if (!parentToggle) {
+        this.warnDependencyOnce(parent.feature, feature.name);
+        return false;
+      }
+      if (parentToggle.dependencies?.length) {
+        return false;
+      }
+
+      if (parent.enabled !== false) {
+        if (parent.variants?.length) {
+          return parent.variants.includes(this.getVariant(parent.feature, context).name);
+        }
+        return this.isEnabled(parent.feature, context, () => false);
+      }
+
+      return !this.isEnabled(parent.feature, context, () => false);
+    });
+  }
+
   isEnabled(name: string, context: Context, fallback: Function): boolean {
     const feature = this.repository.getToggle(name);
-    const { enabled } = this.isFeatureEnabled(feature, context, fallback);
+    let enabled: boolean;
+
+    if (!this.isParentDependencySatisfied(feature, context)) {
+      enabled = false;
+    } else {
+      enabled = this.isFeatureEnabled(feature, context, fallback).enabled;
+    }
+
+    // Emit the impression event if needed
     if (feature?.impressionData) {
       this.emit(
         UnleashEvents.Impression,
@@ -69,6 +119,7 @@ export default class UnleashClient extends EventEmitter {
         }),
       );
     }
+
     return enabled;
   }
 
@@ -92,15 +143,15 @@ export default class UnleashClient extends EventEmitter {
     }
 
     if (feature.strategies.length === 0) {
-      return { enabled: feature.enabled };
+      return { enabled: feature.enabled } as StrategyResult;
     }
 
-    let strategyResult = { enabled: false };
+    let strategyResult: StrategyResult = { enabled: false };
 
     feature.strategies?.some((strategySelector): boolean => {
       const strategy = this.getStrategy(strategySelector.name);
       if (!strategy) {
-        this.warnOnce(strategySelector.name, feature.name, feature.strategies);
+        this.warnStrategyOnce(strategySelector.name, feature.name, feature.strategies);
         return false;
       }
       const constraints = this.yieldConstraintsFor(strategySelector);
@@ -185,7 +236,7 @@ export default class UnleashClient extends EventEmitter {
   ): VariantWithFeatureStatus {
     const fallback = fallbackVariant || getDefaultVariant();
 
-    if (typeof feature === 'undefined') {
+    if (typeof feature === 'undefined' || !this.isParentDependencySatisfied(feature, context)) {
       return { ...fallback, featureEnabled: false };
     }
 

src/feature.ts

@@ -3,6 +3,12 @@ import { Segment } from './strategy/strategy';
 // eslint-disable-next-line import/no-cycle
 import { VariantDefinition } from './variant';
 
+export interface Dependency {
+  feature: string;
+  variants?: string[];
+  enabled?: boolean;
+}
+
 export interface FeatureInterface {
   name: string;
   type: string;
@@ -13,6 +19,7 @@ export interface FeatureInterface {
   impressionData: boolean;
   strategies: StrategyTransportInterface[];
   variants: VariantDefinition[];
+  dependencies?: Dependency[];
 }
 
 export interface ClientFeaturesResponse {

src/test/client.test.ts

@@ -302,6 +302,36 @@ test('should trigger events on isEnabled if impressionData is true', (t) => {
 
 });
 
+test('should trigger events on unsatisfied dependency', (t) => {
+  let impressionCount = 0;
+  let recordedWarnings = [];
+  const repo = {
+    getToggle(name: string) {
+      if(name === 'feature-x') {
+        return {
+          name: 'feature-x',
+          dependencies: [{feature: 'not-feature-x'}],
+          strategies:  [{ name: 'default' }],
+          variants: [],
+          impressionData: true,
+        }
+      } else {
+        return undefined;
+      }
+    },
+  };
+  const client = new Client(repo, []);
+  client.on(UnleashEvents.Impression, () => {
+    impressionCount++;
+  }).on(UnleashEvents.Warn, (warning) => {
+    recordedWarnings.push(warning);
+  });
+  client.isEnabled('feature-x', {}, () => false);
+  client.isEnabled('feature-x', {}, () => false);
+  t.deepEqual(impressionCount, 2);
+  t.deepEqual(recordedWarnings, ['Missing dependency "not-feature-x" for toggle "feature-x"']);
+});
+
 test('should trigger events on getVariant if impressionData is true', (t) => {
   let called = false;
   const repo = {

src/test/unleash.test.ts

@@ -1042,5 +1042,33 @@ test('should report disabled toggle metrics', async (t) => {
   });
 });
 
+test('should not report dependent feature metrics', async (t) => {
+  const { instance, capturedData } = metricsCapturingUnleash({
+    name: 'toggle-with-dependency',
+    enabled: true,
+    dependencies: [{feature: 'dependency'}],
+    strategies: [{ name: 'default', constraints: [] }],
+    variants: [{ name: 'toggle-variant', payload: { type: 'string', value: 'variant value' } }],
+  });
+
+  instance.getVariant('toggle-with-dependency');
+  instance.isEnabled('toggle-with-dependency');
+  instance.isEnabled('dependency');
+
+  await instance.destroyWithFlush();
+  t.deepEqual(capturedData[0].bucket.toggles, {
+    'toggle-with-dependency': {
+      yes: 0,
+      no: 2, // one enabled and one variant check
+      variants: { 'disabled': 1 },
+    },
+    'dependency': {
+      yes: 0,
+      no: 1, // direct call, no transitive calls
+      variants: {}
+    }
+  });
+});
+