flagsmith-nodejs 1.0.9 → 1.1.2

package/flagsmith-core.js

@@ -1,238 +1,243 @@
-let fetch;
-
-const FlagsmithCore = class {
-
-    constructor(props) {
-        fetch = props.fetch;
-
-        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, body) {
-            const { environmentID } = this;
-            const options = {
-                method: method || 'GET',
-                body,
-                headers: {
-                    'x-environment-key': environmentID
-                }
+let fetch = require('node-fetch');
+// https://github.com/node-fetch/node-fetch/issues/450
+if (typeof fetch.default !== "undefined") fetch = fetch.default
+
+module.exports = class FlagsmithCore {
+    normalizeFlags(flags) {
+        const _flags = {};
+
+        for (const { feature, enabled, feature_state_value } of flags) {
+            const normalizedKey = feature.name.toLowerCase().replace(/ /g, '_');
+            _flags[normalizedKey] = {
+                enabled,
+                value: feature_state_value
             };
-            if (method !== "GET") {
-                options.headers['Content-Type'] = 'application/json; charset=utf-8';
-            }
-            return fetch(url, options)
-                .then(res => {
-                    return res.json()
-                    .then(result => {
-                        if (res.status < 200 || res.status >= 400) {
-                            Promise.reject(new Error(result.detail))
-                        } else return result;
-                    })
-                });
-        };
+        }
+
+        return _flags;
     }
 
-    getFlagsForUser (identity) {
-        const { onError, api } = this;
+    normalizeTraits(traits) {
+        const _traits = {};
 
-        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 = {};
-            res.flags.forEach(feature => {
-                flags[feature.feature.name.toLowerCase().replace(/ /g, '_')] = {
-                    enabled: feature.enabled,
-                    value: feature.feature_state_value
-                };
-            });
-            return flags;
-        };
+        for (const { trait_key, trait_value } of traits) {
+            const normalizedKey = trait_key.toLowerCase().replace(/ /g, '_');
+            _traits[normalizedKey] = trait_value;
+        }
 
-        return this.getJSON(api + 'identities/?identifier=' + identity)
-            .then(res => {
-                return handleResponse(res);
-            }).catch(({ message }) => {
-                onError && onError({ message });
-                return Promise.reject(message);
-            });
+        return _traits;
     }
 
-    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 };
+    async getJSON(url, method, body) {
+        const { environmentID } = this;
+        const options = {
+            method: method || 'GET',
+            body,
+            headers: {
+                'x-environment-key': environmentID
+            }
         };
 
-        return this.getJSON(api + 'identities/?identifier=' + identity)
-            .then(res => {
-                return handleResponse(res);
-            }).catch(({ message }) => {
-                onError && onError({ message });
-                return Promise.reject(message);
-            });
-    }
+        if (method !== 'GET') {
+            options.headers['Content-Type'] = 'application/json; charset=utf-8';
+        }
 
-    getFlags() {
-        const { onError, api } = this;
+        const res = await fetch(url, options);
+        const result = await res.json();
 
-        const handleResponse = (res) => {
-            // Handle server response
-            let flags = {};
-            res.forEach(feature => {
-                flags[feature.feature.name.toLowerCase().replace(/ /g, '_')] = {
-                    enabled: feature.enabled,
-                    value: feature.feature_state_value
-                };
-            });
-            return flags;
-        };
+        if (res.status >= 400) {
+            throw new Error(result.detail);
+        }
 
-        return this.getJSON(api + "flags/")
-            .then(res => {
-                return handleResponse(res);
-            }).catch(({ message }) => {
-                onError && onError({ message });
-                return Promise.reject(message);
-            });
-    };
-
-    init({
-             environmentID,
-             api,
-             disableCache,
-             onError,
-         }) {
+        return result;
+    }
+
+    init({ environmentID, api, onError, cache }) {
         if (!environmentID) {
             throw new Error('Please specify a environment id');
         }
 
         this.environmentID = environmentID;
 
-        this.api = api || "https://api.bullet-train.io/api/v1/";
-        this.disableCache = disableCache;
+        this.api = api || 'https://api.flagsmith.com/api/v1';
         this.onError = onError;
-    }
 
-    getValue (key, userId) {
-        if (userId) {
-            return this.getFlagsForUser(userId).then((flags) => {
-                return this.getValueFromFeatures(key, flags);
-            })
-        } else {
-            return this.getFlags().then((flags) => {
-                return this.getValueFromFeatures(key, flags);
+        if (cache) {
+            const missingMethods = [];
+
+            ['has', 'get', 'set'].forEach(method => {
+                if (!cache[method]) missingMethods.push(method);
             });
+
+            if (missingMethods.length > 0) {
+                throw new Error(
+                    `Please implement the following methods in your cache: ${missingMethods.join(
+                        ', '
+                    )}`
+                );
+            }
         }
+
+        this.cache = cache;
     }
 
-    hasFeature (key, userId) {
-        if (userId) {
-            return this.getFlagsForUser(userId).then((flags) => {
-                return this.checkFeatureEnabled(key, flags);
-            })
-        } else {
-            return this.getFlags().then((flags) => {
-                return this.checkFeatureEnabled(key, flags);
-            });
+    async getFlags() {
+        if (this.cache && (await this.cache.has('flags'))) {
+            return this.cache.get('flags');
+        }
+
+        const { onError, api } = this;
+
+        try {
+            const flags = await this.getJSON(`${api}/flags/`);
+            const normalizedFlags = this.normalizeFlags(flags);
+
+            if (this.cache) await this.cache.set('flags', normalizedFlags);
+
+            return normalizedFlags;
+        } catch (err) {
+            onError && onError({ message: err.message });
+            throw err;
         }
     }
 
-    getValueFromFeatures (key, flags) {
-        if (!flags) {
-            return null;
+    async getFlagsForUser(identity) {
+        const cacheKey = `flags-${identity}`;
+
+        if (this.cache && (await this.cache.has(cacheKey))) {
+            return this.cache.get(cacheKey);
         }
-        const flag = flags[key];
-        let res = null;
-        if (flag) {
-            res = flag.value;
+
+        const { onError, api } = this;
+
+        if (!identity) {
+            const errMsg = 'getFlagsForUser() called without a user identity';
+            onError && onError({ message: errMsg });
+            throw new Error(errMsg);
         }
-        //todo record check for value
 
-        return res;
+        try {
+            const { flags } = await this.getJSON(`${api}/identities/?identifier=${identity}`);
+            const normalizedFlags = this.normalizeFlags(flags);
+
+            if (this.cache) await this.cache.set(cacheKey, normalizedFlags);
+
+            return normalizedFlags;
+        } catch (err) {
+            onError && onError({ message: err.message });
+            throw err;
+        }
     }
 
-    checkFeatureEnabled (key, flags) {
-        if (!flags) {
-            return false;
+    async getUserIdentity(identity) {
+        const cacheKey = `flags_traits-${identity}`;
+
+        if (this.cache && (await this.cache.has(cacheKey))) {
+            return this.cache.get(cacheKey);
         }
-        const flag = flags[key];
-        let res = false;
-        if (flag && flag.enabled) {
-            res = true;
+
+        const { onError, api } = this;
+
+        if (!identity) {
+            const errMsg = 'getUserIdentity() called without a user identity';
+            onError && onError({ message: errMsg });
+            throw new Error(errMsg);
+        }
+
+        try {
+            const { flags, traits } = await this.getJSON(
+                `${api}/identities/?identifier=${identity}`
+            );
+
+            const normalizedFlags = this.normalizeFlags(flags);
+            const normalizedTraits = this.normalizeTraits(traits);
+            const res = { flags: normalizedFlags, traits: normalizedTraits };
+
+            if (this.cache) await this.cache.set(cacheKey, res);
+
+            return res;
+        } catch (err) {
+            onError && onError({ message: err.message });
+            throw err;
         }
+    }
+
+    async getValue(key, userId) {
+        const flags = userId ? await this.getFlagsForUser(userId) : await this.getFlags();
+
+        return this.getValueFromFeatures(key, flags);
+    }
+
+    async hasFeature(key, userId) {
+        const flags = userId ? await this.getFlagsForUser(userId) : await this.getFlags();
 
-        return res;
+        return this.checkFeatureEnabled(key, flags);
     }
 
-    getTrait (identity, key) {
+    getValueFromFeatures(key, flags) {
+        if (!flags) return null;
+
+        const flag = flags[key];
+
+        //todo record check for value
+        return flag ? flag.value : null;
+    }
+
+    checkFeatureEnabled(key, flags) {
+        if (!flags) return false;
+
+        const flag = flags[key];
+        return flag && flag.enabled;
+    }
+
+    async 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'}`);
+            const errMsg = `getTrait() called without a ${
+                !identity ? 'user identity' : 'trait key'
+            }`;
+            onError && onError({ message: errMsg });
+            throw new Error(errMsg);
         }
 
-        return this.getUserIdentity(identity)
-            .then(({traits}) => traits[key])
-            .catch(({ message }) => {
-                onError && onError({ message });
-                return Promise.reject(message);
-            });
+        try {
+            const { traits } = await this.getUserIdentity(identity);
+            return traits[key];
+        } catch (err) {
+            onError && onError({ message: err.message });
+            throw err;
+        }
     }
 
-    setTrait (identity, key, value) {
+    async 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'}`);
+            const errMsg = `setTrait() called without a ${
+                !identity ? 'user identity' : 'trait key'
+            }`;
+            onError &&
+                onError({
+                    message: errMsg
+                });
+            throw new Error(errMsg);
         }
 
         const body = {
-            "identity": {
-                "identifier": identity
+            identity: {
+                identifier: identity
             },
-            "trait_key": key,
-            "trait_value": value
-        }
+            trait_key: key,
+            trait_value: value
+        };
 
-        return this.getJSON(`${api}traits/`, 'POST', JSON.stringify(body))
-            .then(() => this.getUserIdentity(identity))
-            .catch(({ message }) => {
-                onError && onError({ message });
-                return Promise.reject(message);
-            });
+        try {
+            await this.getJSON(`${api}/traits/`, 'POST', JSON.stringify(body));
+            return await this.getUserIdentity(identity);
+        } catch (err) {
+            onError && onError({ message: err.message });
+            throw err;
+        }
     }
 };
-
-module.exports = function ({ fetch }) {
-    return new FlagsmithCore({ fetch });
-};

package/index.d.ts

@@ -3,51 +3,52 @@ declare module 'flagsmith-nodejs' {
      * Initialise the sdk against a particular environment
      */
     export function init(config: {
-        environmentID: string
-        onError?: Function
-        defaultFlags?: string[]
-        api?: string
-    }): void
+        environmentID: string;
+        onError?: Function;
+        defaultFlags?: string[];
+        api?: string;
+        cache?: ICache;
+    }): void;
 
     /**
      * Get the whether a flag is enabled e.g. flagsmith.hasFeature("powerUserFeature")
      */
-    export function hasFeature(key: string): Promise<boolean>
+    export function hasFeature(key: string): Promise<boolean>;
 
     /**
      * Get the value of a whether a flag is enabled for a user e.g. flagsmith.hasFeature("powerUserFeature", 1234)
      */
-    export function hasFeature(key: string, userId: string): Promise<boolean>
+    export function hasFeature(key: string, userId: string): Promise<boolean>;
 
     /**
      * Get the value of a particular remote config e.g. flagsmith.getValue("font_size")
      */
-    export function getValue(key: string): Promise<string|number|boolean>
+    export function getValue(key: string): Promise<string | number | boolean>;
 
     /**
      * Get the value of a particular remote config for a specified user e.g. flagsmith.getValue("font_size", 1234)
      */
-    export function getValue(key: string, userId: string): Promise<string|number|boolean>
+    export function getValue(key: string, userId: string): Promise<string | number | boolean>;
 
     /**
      * Trigger a manual fetch of the environment features
      */
-    export function getFlags(): Promise<IFlags>
+    export function getFlags(): Promise<IFlags>;
 
     /**
      * Trigger a manual fetch of the environment features for a given user id
      */
-    export function getFlagsForUser(userId: string): Promise<IFlags>
+    export function getFlagsForUser(userId: string): Promise<IFlags>;
 
     /**
      * Trigger a manual fetch of both the environment features and users' traits for a given user id
      */
-    export function getUserIdentity(userId: string): Promise<IUserIdentity>
+    export function getUserIdentity(userId: string): Promise<IUserIdentity>;
 
     /**
      * Trigger a manual fetch of a specific trait for a given user id
      */
-    export function getTrait(userId: string, key: string): Promise<ITraits>
+    export function getTrait(userId: string, key: string): Promise<ITraits>;
 
     /**
      * Set a specific trait for a given user id
@@ -55,24 +56,30 @@ declare module 'flagsmith-nodejs' {
     export function setTrait(
         userId: string,
         key: string,
-        value: string|number|boolean
-    ): IUserIdentity
+        value: string | number | boolean
+    ): Promise<IUserIdentity>;
 
     interface IFeature {
-        enabled: boolean
-        value?: string|number|boolean
+        enabled: boolean;
+        value?: string | number | boolean;
     }
 
     interface IFlags {
-        [key: string]: IFeature
+        [key: string]: IFeature;
     }
 
     interface ITraits {
-        [key: string]: string
+        [key: string]: string;
     }
 
     interface IUserIdentity {
-        flags: IFeature
-        traits: ITraits
+        flags: IFeature;
+        traits: ITraits;
+    }
+
+    interface ICache {
+        has(key: string): boolean | Promise<boolean>;
+        get(key: string): any | Promise<any>;
+        set(key: string, val: any): void | Promise<void>;
     }
 }

package/index.js

@@ -1,5 +1,3 @@
-const fetch = require('node-fetch').default;
-const core = require('./flagsmith-core');
-const flagsmith = core({fetch: fetch});
+const FlagsmithCore = require('./flagsmith-core');
 
-module.exports = flagsmith;
+module.exports = new FlagsmithCore();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flagsmith-nodejs",
-  "version": "1.0.9",
+  "version": "1.1.2",
   "description": "Flagsmith lets you manage features flags and remote config across web, mobile and server side applications. Deliver true Continuous Integration. Get builds out faster. Control who has access to new features.",
   "main": "index.js",
   "repository": {
@@ -39,7 +39,13 @@
     }
   ],
   "license": "MIT",
+  "scripts": {
+    "lint": "prettier --write ."
+  },
   "dependencies": {
     "node-fetch": "^2.1.2"
+  },
+  "devDependencies": {
+    "prettier": "^2.2.1"
   }
 }