Merge pull request #92 from launchdarkly/eb/ch21387/bootstrap-metadata

support extended bootstrap data format

Author: eli-darkly

src/__tests__/LDClient-test.js

@@ -158,7 +158,7 @@ describe('LDClient', () => {
       requests[0].respond(404);
     });
 
-    it('should not fetch flag settings since bootstrap is provided', () => {
+    it('should not fetch flag settings if bootstrap is provided', () => {
       LDClient.initialize(envName, user, {
         bootstrap: {},
       });
@@ -167,6 +167,38 @@ describe('LDClient', () => {
       expect(/sdk\/eval/.test(settingsRequest.url)).toEqual(false);
     });
 
+    it('sets flag values from bootstrap object with old format', () => {
+      const client = LDClient.initialize(envName, user, {
+        bootstrap: { foo: 'bar' },
+      });
+
+      expect(client.variation('foo')).toEqual('bar');
+    });
+
+    it('logs warning when bootstrap object uses old format', () => {
+      LDClient.initialize(envName, user, {
+        bootstrap: { foo: 'bar' },
+      });
+
+      expect(warnSpy).toHaveBeenCalledWith(messages.bootstrapOldFormat());
+    });
+
+    it('sets flag values from bootstrap object with new format', () => {
+      const client = LDClient.initialize(envName, user, {
+        bootstrap: { foo: 'bar', $flagsState: { foo: { version: 1 } } },
+      });
+
+      expect(client.variation('foo')).toEqual('bar');
+    });
+
+    it('does not log warning when bootstrap object uses new format', () => {
+      LDClient.initialize(envName, user, {
+        bootstrap: { foo: 'bar', $flagsState: { foo: { version: 1 } } },
+      });
+
+      expect(warnSpy).not.toHaveBeenCalled();
+    });
+
     it('should contain package version', () => {
       // Arrange
       const version = LDClient.version;
@@ -420,13 +452,15 @@ describe('LDClient', () => {
       expect(e.user).toEqual(user);
     }
 
-    function expectFeatureEvent(e, key, value, variation, version, defaultVal) {
+    function expectFeatureEvent(e, key, value, variation, version, defaultVal, trackEvents, debugEventsUntilDate) {
       expect(e.kind).toEqual('feature');
       expect(e.key).toEqual(key);
       expect(e.value).toEqual(value);
       expect(e.variation).toEqual(variation);
       expect(e.version).toEqual(version);
       expect(e.default).toEqual(defaultVal);
+      expect(e.trackEvents).toEqual(trackEvents);
+      expect(e.debugEventsUntilDate).toEqual(debugEventsUntilDate);
     }
 
     it('sends an identify event at startup', done => {
@@ -513,6 +547,32 @@ describe('LDClient', () => {
 
       server.respond();
     });
+
+    it('can get metadata for events from bootstrap object', done => {
+      const ep = stubEventProcessor();
+      const bootstrapData = {
+        foo: 'bar',
+        $flagsState: {
+          foo: {
+            variation: 1,
+            version: 2,
+            trackEvents: true,
+            debugEventsUntilDate: 1000,
+          },
+        },
+      };
+      const client = LDClient.initialize(envName, user, { eventProcessor: ep, bootstrap: bootstrapData });
+
+      client.on('ready', () => {
+        client.variation('foo', 'x');
+
+        expect(ep.events.length).toEqual(2);
+        expectIdentifyEvent(ep.events[0], user);
+        expectFeatureEvent(ep.events[1], 'foo', 'bar', 1, 2, 'x', true, 1000);
+
+        done();
+      });
+    });
   });
 
   describe('event listening', () => {

src/index.js

@@ -28,13 +28,38 @@ export function initialize(env, user, options = {}) {
   const events = options.eventProcessor || EventProcessor(eventsUrl, environment, options, emitter);
   const requestor = Requestor(baseUrl, environment, options.useReport);
   const seenRequests = {};
-  let flags = typeof options.bootstrap === 'object' ? utils.transformValuesToVersionedValues(options.bootstrap) : {};
+  let flags = typeof options.bootstrap === 'object' ? readFlagsFromBootstrap(options.bootstrap) : {};
   let goalTracker;
   let useLocalStorage;
   let goals;
   let subscribedToChangeEvents;
   let firstEvent = true;
 
+  function readFlagsFromBootstrap(data) {
+    // If the bootstrap data came from an older server-side SDK, we'll have just a map of keys to values.
+    // Newer SDKs that have an allFlagsState method will provide an extra "$flagsState" key that contains
+    // the rest of the metadata we want. We do it this way for backward compatibility with older JS SDKs.
+    const keys = Object.keys(data);
+    const metadataKey = '$flagsState';
+    const metadata = data[metadataKey];
+    if (!metadata && keys.length) {
+      console.warn(messages.bootstrapOldFormat());
+    }
+    const ret = {};
+    keys.forEach(key => {
+      if (key !== metadataKey) {
+        let flag = { value: data[key] };
+        if (metadata && metadata[key]) {
+          flag = utils.extend(flag, metadata[key]);
+        } else {
+          flag.version = 0;
+        }
+        ret[key] = flag;
+      }
+    });
+    return ret;
+  }
+
   function shouldEnqueueEvent() {
     return sendEvents && !doNotTrack();
   }

src/messages.js

@@ -37,6 +37,14 @@ export const invalidUser = function() {
   return 'Invalid user specified.' + docLink;
 };
 
+export const bootstrapOldFormat = function() {
+  return (
+    'LaunchDarkly client was initialized with bootstrap data that did not include flag metadata. ' +
+    'Events may not be sent correctly.' +
+    docLink
+  );
+};
+
 export const deprecated = function(oldName, newName) {
   return '[LaunchDarkly] "' + oldName + '" is deprecated, please use "' + newName + '"';
 };