Add client-side feature event and allFlags test.

Author: kinyoklion

packages/shared/sdk-client/__tests__/LDClientImpl.events.test.ts

@@ -199,4 +199,45 @@ describe('sdk-client object', () => {
       expect.stringMatching(/was called with a non-numeric/),
     );
   });
+
+  it('sends events for prerequisite flags', async () => {
+    await ldc.identify({ kind: 'user', key: 'bob' });
+    ldc.variation('has-prereq-depth-1', false);
+    ldc.flush();
+
+    // Prerequisite evaluation event should be emitted before the evaluation event for the flag
+    // being evaluated.
+    expect(mockedSendEvent).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
+        context: expect.anything(),
+        creationDate: expect.any(Number),
+        default: undefined,
+        key: 'is-prereq',
+        kind: 'feature',
+        samplingRatio: 1,
+        trackEvents: true,
+        value: true,
+        variation: 0,
+        version: 1,
+        withReasons: false,
+      }),
+    );
+    expect(mockedSendEvent).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining({
+        context: expect.anything(),
+        creationDate: expect.any(Number),
+        default: false,
+        key: 'has-prereq-depth-1',
+        kind: 'feature',
+        samplingRatio: 1,
+        trackEvents: true,
+        value: true,
+        variation: 0,
+        version: 4,
+        withReasons: false,
+      }),
+    );
+  });
 });

packages/shared/sdk-client/__tests__/evaluation/mockResponse.json

@@ -54,5 +54,24 @@
     "value": true,
     "variation": 0,
     "trackEvents": false
+  },
+  "is-prereq": {
+    "value": true,
+    "variation": 0,
+    "reason": {
+      "kind": "FALLTHROUGH"
+    },
+    "version": 1,
+    "trackEvents": true
+  },
+  "has-prereq-depth-1": {
+    "value": true,
+    "variation": 0,
+    "prerequisites": ["is-prereq"],
+    "reason": {
+      "kind": "FALLTHROUGH"
+    },
+    "version": 4,
+    "trackEvents": true
   }
 }

packages/shared/sdk-client/src/LDClientImpl.ts

@@ -535,7 +535,7 @@ export default class LDClientImpl implements LDClient {
       return createErrorEvaluationDetail(ErrorKinds.FlagNotFound, defaultValue);
     }
 
-    const { reason, value, variation } = foundItem.flag;
+    const { reason, value, variation, prerequisites } = foundItem.flag;
 
     if (typeChecker) {
       const [matched, type] = typeChecker(value);
@@ -558,11 +558,27 @@ export default class LDClientImpl implements LDClient {
       }
     }
 
-    const successDetail = createSuccessEvaluationDetail(value, variation, reason);
+    const successDetail = createSuccessEvaluationDetail(value, variation, reason, prerequisites);
     if (value === undefined || value === null) {
       this.logger.debug('Result value is null. Providing default value.');
       successDetail.value = defaultValue;
     }
+
+    successDetail.prerequisites?.forEach((prereqKey) => {
+      const prereqFlag = this.flagManager.get(prereqKey);
+      if (prereqFlag) {
+        this.eventProcessor?.sendEvent(
+          eventFactory.evalEventClient(
+            prereqKey,
+            prereqFlag.flag.value,
+            undefined,
+            prereqFlag.flag,
+            evalContext,
+            prereqFlag.flag.reason,
+          ),
+        );
+      }
+    });
     this.eventProcessor?.sendEvent(
       eventFactory.evalEventClient(
         flagKey,

packages/shared/sdk-client/src/evaluation/evaluationDetail.ts

@@ -17,10 +17,12 @@ export function createSuccessEvaluationDetail(
   value: LDFlagValue,
   variationIndex?: number,
   reason?: LDEvaluationReason,
+  prerequisites?: string[],
 ): LDEvaluationDetail {
   return {
     value,
     variationIndex: variationIndex ?? null,
     reason: reason ?? null,
+    prerequisites,
   };
 }

packages/shared/sdk-client/src/types/index.ts

@@ -10,6 +10,7 @@ export interface Flag {
   reason?: LDEvaluationReason;
   debugEventsUntilDate?: number;
   deleted?: boolean;
+  prerequisites?: string[];
 }
 
 export interface PatchFlag extends Flag {

packages/shared/sdk-server/__tests__/LDClient.allFlags.test.ts

@@ -269,6 +269,60 @@ describe('given an LDClient with test data', () => {
       done();
     });
   });
+
+  it('includes prerequisites in flag meta', async () => {
+    await td.update(td.flag('is-prereq').valueForAll(true));
+    await td.usePreconfiguredFlag({
+      key: 'has-prereq-depth-1',
+      on: true,
+      prerequisites: [
+        {
+          key: 'is-prereq',
+          variation: 0,
+        },
+      ],
+      fallthrough: {
+        variation: 0,
+      },
+      offVariation: 1,
+      variations: [true, false],
+      clientSideAvailability: {
+        usingMobileKey: true,
+        usingEnvironmentId: true,
+      },
+      clientSide: true,
+      version: 4,
+    });
+
+    const state = await client.allFlagsState(defaultUser, {
+      withReasons: true,
+      detailsOnlyForTrackedFlags: false,
+    });
+    expect(state.valid).toEqual(true);
+    expect(state.allValues()).toEqual({ 'is-prereq': true, 'has-prereq-depth-1': true });
+    expect(state.toJSON()).toEqual({
+      'is-prereq': true,
+      'has-prereq-depth-1': true,
+      $flagsState: {
+        'is-prereq': {
+          variation: 0,
+          reason: {
+            kind: 'FALLTHROUGH',
+          },
+          version: 1,
+        },
+        'has-prereq-depth-1': {
+          variation: 0,
+          prerequisites: ['is-prereq'],
+          reason: {
+            kind: 'FALLTHROUGH',
+          },
+          version: 4,
+        },
+      },
+      $valid: true,
+    });
+  });
 });
 
 describe('given an offline client', () => {