Merge pull request #77 from launchdarkly/christie/sc-164657/no-variation-call-on-init

No variation call on init

Author: XieX

src/getFlagsProxy.test.ts

@@ -50,3 +50,11 @@ test('filters to target flags', () => {
 
   expect(flags).toEqual({ fooBar: 'foobar' });
 });
+
+test('does not use proxy if option is false', () => {
+  const { flags } = getFlagsProxy(ldClient, rawFlags, { sendEventsOnFlagRead: false });
+
+  expect(flags['foo-bar']).toBe('foobar');
+
+  expect(variation).not.toHaveBeenCalled();
+});

src/getFlagsProxy.ts

@@ -26,7 +26,7 @@ export default function getFlagsProxy(
   }
 
   return {
-    flags: toFlagsProxy(ldClient, flags, flagKeyMap),
+    flags: reactOptions.sendEventsOnFlagRead ? toFlagsProxy(ldClient, flags, flagKeyMap) : flags,
     flagKeyMap,
   };
 }

src/initLDClient.test.ts

@@ -58,18 +58,6 @@ describe('initLDClient', () => {
     expect(mockLDClient.variation).toHaveBeenCalledTimes(0);
   });
 
-  test('initialise should call variation if flags are specified', async () => {
-    const customUser = { key: '[email protected]' };
-    const targetFlags = { 'lonely-flag': false, 'lonelier-flag': false };
-
-    const flagsClient = await initLDClient(clientSideID, customUser, options, targetFlags);
-
-    expect(mockLDClient.variation).toHaveBeenCalledTimes(2);
-    expect(mockLDClient.variation).toHaveBeenNthCalledWith(1, 'lonely-flag', false);
-    expect(mockLDClient.variation).toHaveBeenNthCalledWith(2, 'lonelier-flag', false);
-    expect(flagsClient).toEqual({ flags: { 'lonely-flag': true, 'lonelier-flag': true }, ldClient: mockLDClient });
-  });
-
   test('may explicity set sendEventsOnlyForVariation to false', async () => {
     const anonUser: LDUser = { anonymous: true };
     await initLDClient(clientSideID, undefined, { ...options, sendEventsOnlyForVariation: false });

src/types.ts

@@ -21,12 +21,19 @@ export interface LDReactOptions {
    * @see https://docs.launchdarkly.com/sdk/client-side/react/react-web#flag-keys
    */
   useCamelCaseFlagKeys?: boolean;
+
+  /**
+   * Whether to send flag evaluation events when a flag is read from the `flags` object
+   * retured by the `useFlags` hook. This is true by default, meaning flag evaluation
+   * events will be sent by default.
+   */
+  sendEventsOnFlagRead?: boolean;
 }
 
 /**
  * Contains default values for the `reactOptions` object.
  */
-export const defaultReactOptions = { useCamelCaseFlagKeys: true };
+export const defaultReactOptions = { useCamelCaseFlagKeys: true, sendEventsOnFlagRead: true };
 
 /**
  * Configuration object used to initialise LaunchDarkly's JS client.

src/utils.test.ts

@@ -85,20 +85,17 @@ describe('Utils', () => {
       };
     });
 
-    test('should return variations for the target flags', () => {
+    test('should return only the target flags', () => {
       const targetFlags = { 'target-one': true, 'target-two': true, 'target-three': false };
       const flagSet = fetchFlags(mockLDClient as LDClient, targetFlags);
 
-      expect(mockLDClient.allFlags).toBeCalledTimes(0);
-      expect(mockLDClient.variation).toBeCalledTimes(3);
       expect(flagSet).toEqual({ 'target-one': true, 'target-three': false, 'target-two': true });
     });
 
     test('should return all flags when target flags is not defined', () => {
       const flagSet = fetchFlags(mockLDClient as LDClient, undefined);
 
       expect(mockLDClient.allFlags).toBeCalledTimes(1);
-      expect(mockLDClient.variation).toBeCalledTimes(0);
       expect(flagSet).toEqual({ 'example-flag': true, 'test-example': false });
     });
   });

src/utils.ts

@@ -53,17 +53,16 @@ export const getFlattenedFlagsFromChangeset = (
  * @returns an `LDFlagSet` with the current flag values from LaunchDarkly filtered by `targetFlags`.
  */
 export const fetchFlags = (ldClient: LDClient, targetFlags?: LDFlagSet) => {
-  let rawFlags: LDFlagSet = {};
-
-  if (targetFlags) {
-    for (const flag in targetFlags) {
-      rawFlags[flag] = ldClient.variation(flag, targetFlags[flag]);
-    }
-  } else {
-    rawFlags = ldClient.allFlags();
+  const allFlags = ldClient.allFlags();
+  if (!targetFlags) {
+    return allFlags;
   }
 
-  return rawFlags;
+  return Object.keys(targetFlags).reduce<LDFlagSet>((acc, key) => {
+    acc[key] = Object.prototype.hasOwnProperty.call(allFlags, key) ? allFlags[key] : targetFlags[key];
+
+    return acc;
+  }, {});
 };
 
 /**