Adds getUserIdentity(), getTrait() and setTrait(). Promise rejection if identity not provided

bullet-train-core.js

@@ -9,52 +9,88 @@ const BulletTrain = class {
         this.checkFeatureEnabled = this.checkFeatureEnabled.bind(this);
         this.getFlags = this.getFlags.bind(this);
         this.getFlagsForUser = this.getFlagsForUser.bind(this);
+        this.getUserIdentity = this.getUserIdentity.bind(this);
         this.getValue = this.getValue.bind(this);
         this.getValueFromFeatures = this.getValueFromFeatures.bind(this);
         this.hasFeature = this.hasFeature.bind(this);
         this.init = this.init.bind(this);
 
-        this.getJSON = function (url, method) {
+        this.getJSON = function (url, method, body) {
             const { environmentID } = this;
-            return fetch(url + '?format=json', {
+            const options = {
                 method: method || 'GET',
+                body,
                 headers: {
                     'x-environment-key': environmentID
                 }
-            })
+            };
+            if (method !== "GET") {
+                options.headers['Content-Type'] = 'application/json; charset=utf-8';
+            }
+            return fetch(url + '?format=json', options)
                 .then(res => res.json());
         };
     }
 
     getFlagsForUser (identity) {
         const { onError, api } = this;
-        //Because timer functions get the timeout context we need to pass through the explicit self on timers
+
+        if (!identity) {
+            onError && onError({message: 'getFlagsForUser() called without a user identity'});
+            return Promise.reject('getFlagsForUser() called without a user identity');
+        }
 
         const handleResponse = (res) => {
             // Handle server response
             let flags = {};
-            let userFlags = {};
             res.forEach(feature => {
-                if (identity) {
-                    if (userFlags[identity] === undefined) {
-                        userFlags[identity] = {};
-                    }
-                    userFlags[identity][feature.feature.name.toLowerCase().replace(/ /g, '_')] = {
-                        enabled: feature.enabled,
-                        value: feature.feature_state_value
-                    };
-                }
+                flags[feature.feature.name.toLowerCase().replace(/ /g, '_')] = {
+                    enabled: feature.enabled,
+                    value: feature.feature_state_value
+                };
             });
-            return userFlags;
+            return flags;
         };
 
         return this.getJSON(api + 'flags/' + identity)
             .then(res => {
-                return handleResponse(res, identity);
-            }).then((flags) => {
-                return flags[identity];
+                return handleResponse(res);
+            }).catch(({ message }) => {
+                onError && onError({ message });
+                return Promise.reject(message);
+            });
+    }
+
+    getUserIdentity (identity) {
+        const { onError, api } = this;
+
+        if (!identity) {
+            onError && onError({message: 'getUserIdentity() called without a user identity'});
+            return Promise.reject('getUserIdentity() called without a user identity');
+        }
+
+        const handleResponse = (res) => {
+            // Handle server response
+            let flags = {};
+            let traits = {};
+            res.flags.forEach(feature => {
+                flags[feature.feature.name.toLowerCase().replace(/ /g, '_')] = {
+                    enabled: feature.enabled,
+                    value: feature.feature_state_value
+                };
+            });
+            res.traits.forEach(({trait_key, trait_value}) => {
+                traits[trait_key.toLowerCase().replace(/ /g, '_')] = trait_value;
+            });
+            return { flags, traits };
+        };
+
+        return this.getJSON(api + 'identities/' + identity + '/')
+            .then(res => {
+                return handleResponse(res);
             }).catch(({ message }) => {
-                onError && onError({ message })
+                onError && onError({ message });
+                return Promise.reject(message);
             });
     }
 
@@ -77,7 +113,8 @@ const BulletTrain = class {
             .then(res => {
                 return handleResponse(res);
             }).catch(({ message }) => {
-                onError && onError({ message })
+                onError && onError({ message });
+                return Promise.reject(message);
             });
     };
 
@@ -152,6 +189,38 @@ const BulletTrain = class {
 
         return res;
     }
+
+    getTrait (identity, key) {
+        const { onError } = this;
+
+        if (!identity || !key) {
+            onError && onError({message: `getTrait() called without a ${!identity ? 'user identity' : 'trait key'}`});
+            return Promise.reject(`getTrait() called without a ${!identity ? 'user identity' : 'trait key'}`);
+        }
+
+        return this.getUserIdentity(identity)
+            .then(({traits}) => traits[key])
+            .catch(({ message }) => {
+                onError && onError({ message });
+                return Promise.reject(message);
+            });
+    }
+
+    setTrait (identity, key, value) {
+        const { onError, api } = this;
+
+        if (!identity || !key) {
+            onError && onError({message: `setTrait() called without a ${!identity ? 'user identity' : 'trait key'}`});
+            return Promise.reject(`setTrait() called without a ${!identity ? 'user identity' : 'trait key'}`);
+        }
+
+        return this.getJSON(`${api}identities/${identity}/traits/${encodeURIComponent(key)}`, 'POST', JSON.stringify({ trait_value: value }))
+            .then(() => this.getUserIdentity(identity))
+            .catch(({ message }) => {
+                onError && onError({ message });
+                return Promise.reject(message);
+            });
+    }
 };
 
 module.exports = function ({ fetch }) {