@autofleet/settings 1.0.5-beta-3 → 1.0.6

package/dist/index.js

@@ -29,7 +29,7 @@ const waitingToNetwork = 'waitingToNetwork';
 const findUrl = (serviceUrl) => serviceUrl
     || (process.env.SETTING_MS_SERVICE_HOST && process.env.SETTING_MS_SERVICE_HOST.length > 0 ? `http://${process.env.SETTING_MS_SERVICE_HOST}/` : undefined)
     || (process.env.NODE_ENV !== 'test' ? 'http://setting-ms.autofleet.io/' : 'http://localhost:9999/');
-class ConnotGetNetworkValueError extends Error {
+class CannotGetNetworkValueError extends Error {
 }
 class SettingsManager {
     constructor({ serviceUrl, ttl = fiveMinutes } = {}) {
@@ -87,7 +87,7 @@ class SettingsManager {
             catch (error) {
                 logger.error('Cant get setting from network');
                 if (rejectOnFail) {
-                    throw new ConnotGetNetworkValueError();
+                    throw new CannotGetNetworkValueError();
                 }
             }
             this.networkEvents.emit(cacheKey, networkValue);
@@ -105,56 +105,49 @@ class SettingsManager {
     }
     getMultiple(settingsToGet, labels, { timeout = 5000, rejectOnFail = false } = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            settingsToGet.map((obj) => {
-                if (typeof obj.defaultValue === 'undefined') {
-                    throw new Error(`Missing default value for key ${obj.key}`);
-                }
-            });
+            const settingsToReturn = new Map();
+            const settingsToFetch = [];
             if (process.env.NODE_ENV === 'test') {
                 return settingsToGet.map((obj) => obj.defaultValue);
             }
-            settingsToGet.map((obj) => __awaiter(this, void 0, void 0, function* () {
+            settingsToGet.map((obj) => {
                 const cacheKey = `${obj.key}_${JSON.stringify(labels)}`;
                 const cacheValue = this.settingsCache.get(cacheKey);
-                if (cacheValue !== undefined) {
-                    if (waitingToNetwork === cacheValue) {
-                        yield nextTick();
-                        return new Promise((resolve) => {
-                            this.networkEvents.once(cacheKey, (networkValue) => {
-                                resolve(SettingsManager.readNetworkValue(networkValue, obj.defaultValue));
-                            });
-                        });
-                    }
+                if (cacheValue) {
+                    settingsToReturn.set(obj.key, cacheValue);
+                }
+                else {
+                    settingsToFetch.push(obj.key);
                 }
-            }));
-            settingsToGet.map((obj) => {
-                const cacheKey = `${obj.key}_${JSON.stringify(labels)}`;
-                this.settingsCache.set(cacheKey, waitingToNetwork, this.ttl);
             });
-            let settings;
-            try {
-                const { data } = yield this.network.get('/api/v1/settings', {
-                    params: {
-                        keys: settingsToGet.map((obj) => obj.key),
-                        labels,
-                    },
-                    timeout,
-                });
-                settings = data;
-            }
-            catch (err) {
-                logger.error('Cant get setting from network');
-                if (rejectOnFail) {
-                    throw new ConnotGetNetworkValueError();
+            if (settingsToFetch.length > 0) {
+                let values;
+                try {
+                    const { data } = yield this.network.get('/api/v1/settings', {
+                        params: {
+                            keys: settingsToFetch,
+                            labels,
+                            skipEntityQueryAddition: true,
+                        },
+                        timeout,
+                    });
+                    values = data;
+                    settingsToFetch.map((key, index) => {
+                        settingsToReturn.set(key, values[index]);
+                    });
+                }
+                catch (err) {
+                    logger.error('Cant get setting from network', { err });
+                    if (rejectOnFail) {
+                        throw new CannotGetNetworkValueError();
+                    }
                 }
             }
-            // eslint-disable-next-line array-callback-return
-            settings.map((setting, index) => {
-                const cacheKey = `${settingsToGet[index].key}_${JSON.stringify(labels)}`;
-                this.networkEvents.emit(cacheKey, setting);
+            return settingsToGet.map((setting) => {
+                const cacheKey = `${setting.key}_${JSON.stringify(labels)}`;
                 let returnValue;
                 try {
-                    returnValue = SettingsManager.readNetworkValue(setting, settingsToGet[index].defaultValue);
+                    returnValue = SettingsManager.readNetworkValue(settingsToReturn.get(setting.key), setting.defaultValue);
                 }
                 catch (err) {
                     this.settingsCache.del(cacheKey);
@@ -163,7 +156,6 @@ class SettingsManager {
                 this.settingsCache.set(cacheKey, returnValue, this.ttl);
                 return returnValue;
             });
-            return settings;
         });
     }
     setLocal(key, labels, value) {

package/dist/index.test.js

@@ -23,129 +23,188 @@ const mockSetting = (key, value, labels = undefined, response = 200) => {
         .query(labels ? { labels } : undefined);
     return n.reply(response, { value });
 };
+const mockMultipleSettings = (keys, values, response = 200) => {
+    const n = nock(`http://${serviceUrl}`)
+        .get('/api/v1/settings')
+        .query({
+        keys,
+        skipEntityQueryAddition: true,
+    });
+    return n.reply(response, values);
+};
 describe('Settings', () => {
-    it('Throws exeption if there is no defualt value', () => __awaiter(void 0, void 0, void 0, function* () {
-        const settings = new index_1.default({
-            serviceUrl: `http://${serviceUrl}/`,
-        });
-        expect(settings.get('key1'))
-            .rejects.toEqual(new Error('Can\'t get a key without defaultValue'));
-    }));
-    it('Can get 0 as default value', () => __awaiter(void 0, void 0, void 0, function* () {
-        const settings = new index_1.default({
-            serviceUrl: `http://${serviceUrl}/`,
-        });
-        expect(yield settings.get('key1', 0)).toBe(0);
-    }));
-    it('Can get false as default value', () => __awaiter(void 0, void 0, void 0, function* () {
-        const settings = new index_1.default({
-            serviceUrl: `http://${serviceUrl}/`,
-        });
-        expect(yield settings.get('key1', false)).toBe(false);
-    }));
-    it('Uses env.SETTING_MS_SERVICE_HOST as service host if no one defined', () => __awaiter(void 0, void 0, void 0, function* () {
-        const m = mockSetting('key1', 'value1');
-        process.env.SETTING_MS_SERVICE_HOST = serviceUrl;
-        const settings = new index_1.default();
-        const value = yield settings.get('key1', 'dv');
-        expect(value).toEqual('value1');
-        expect(m.isDone()).toBeTruthy();
-        process.env.SETTING_MS_SERVICE_HOST = '';
-    }));
-    it('Get a key from server', () => __awaiter(void 0, void 0, void 0, function* () {
-        const m = mockSetting('key1', 'value1');
-        const settings = new index_1.default({
-            serviceUrl: `http://${serviceUrl}/`,
-        });
-        const value = yield settings.get('key1', 'dv');
-        expect(value).toEqual('value1');
-        expect(m.isDone()).toBeTruthy();
-    }));
-    it('Cache from server', () => __awaiter(void 0, void 0, void 0, function* () {
-        const m = mockSetting('key1', 'value1');
-        const settings = new index_1.default({
-            serviceUrl: `http://${serviceUrl}/`,
-        });
-        const value = yield settings.get('key1', 'dv');
-        expect(value).toEqual('value1');
-        expect(m.isDone()).toBeTruthy();
-        const value2 = yield settings.get('key1', 'dv');
-        expect(value2).toEqual('value1');
-    }));
-    it('Use only one request for similar keys', () => __awaiter(void 0, void 0, void 0, function* () {
-        const m = mockSetting('key1EM', 'value1EM');
-        const settings = new index_1.default({
-            serviceUrl: `http://${serviceUrl}/`,
-        });
-        const [value, value2] = yield Promise.all([
-            settings.get('key1EM', 'dv'),
-            settings.get('key1EM', 'dv'),
-        ]);
-        expect(value).toEqual('value1EM');
-        expect(m.isDone()).toBeTruthy();
-        expect(value2).toEqual('value1EM');
-    }));
-    it('Finds with labels', () => __awaiter(void 0, void 0, void 0, function* () {
-        const labels = [{ fleetId: 'uuid' }];
-        const m = mockSetting('key1', 'value1', labels);
-        const settings = new index_1.default({
-            serviceUrl: `http://${serviceUrl}/`,
-        });
-        const value = yield settings.get('key1', 'dv', labels);
-        expect(value).toEqual('value1');
-        expect(m.isDone()).toBeTruthy();
-    }));
-    it('Returns default value when network error', () => __awaiter(void 0, void 0, void 0, function* () {
-        const settings = new index_1.default({
-            serviceUrl: `http://${serviceUrl}/`,
-        });
-        const value = yield settings.get('key1', 'dv', [{ fleetId: 'uuid' }]);
-        expect(value).toEqual('dv');
-    }));
-    it('Throws an error if network error and no default value', () => __awaiter(void 0, void 0, void 0, function* () {
-        const settings = new index_1.default({
-            serviceUrl: `http://${serviceUrl}/`,
-        });
-        const f = () => settings.get('key1', settings.NEVER_DEFAULT_VALUE, [{ fleetId: 'uuid' }]);
-        expect(f())
-            .rejects.toEqual(new Error('Cannot find value from network or cache, default value is set to never'));
-    }));
-    it('Throws an error if network error and no default value and success the next time', (done) => __awaiter(void 0, void 0, void 0, function* () {
-        const settings = new index_1.default({
-            serviceUrl: `http://${serviceUrl}/`,
-        });
-        const f = () => settings.get('key1', settings.NEVER_DEFAULT_VALUE);
-        expect(f())
-            .rejects.toEqual(new Error('Cannot find value from network or cache, default value is set to never'));
-        setTimeout(() => __awaiter(void 0, void 0, void 0, function* () {
+    describe('get', () => {
+        it('Throws exeption if there is no defualt value', () => __awaiter(void 0, void 0, void 0, function* () {
+            const settings = new index_1.default({
+                serviceUrl: `http://${serviceUrl}/`,
+            });
+            expect(settings.get('key1'))
+                .rejects.toEqual(new Error('Can\'t get a key without defaultValue'));
+        }));
+        it('Can get 0 as default value', () => __awaiter(void 0, void 0, void 0, function* () {
+            const settings = new index_1.default({
+                serviceUrl: `http://${serviceUrl}/`,
+            });
+            expect(yield settings.get('key1', 0)).toBe(0);
+        }));
+        it('Can get false as default value', () => __awaiter(void 0, void 0, void 0, function* () {
+            const settings = new index_1.default({
+                serviceUrl: `http://${serviceUrl}/`,
+            });
+            expect(yield settings.get('key1', false)).toBe(false);
+        }));
+        it('Uses env.SETTING_MS_SERVICE_HOST as service host if no one defined', () => __awaiter(void 0, void 0, void 0, function* () {
+            const m = mockSetting('key1', 'value1');
+            process.env.SETTING_MS_SERVICE_HOST = serviceUrl;
+            const settings = new index_1.default();
+            const value = yield settings.get('key1', 'dv');
+            expect(value).toEqual('value1');
+            expect(m.isDone()).toBeTruthy();
+            process.env.SETTING_MS_SERVICE_HOST = '';
+        }));
+        it('Get a key from server', () => __awaiter(void 0, void 0, void 0, function* () {
             const m = mockSetting('key1', 'value1');
-            expect(yield settings.get('key1', settings.NEVER_DEFAULT_VALUE)).toEqual('value1');
-            expect(m.isDone());
-            done();
-        }), 100);
-    }));
-    it('Values can be flushed', () => __awaiter(void 0, void 0, void 0, function* () {
-        const m1 = mockSetting('key1', 'value1');
-        const settings = new index_1.default({
-            serviceUrl: `http://${serviceUrl}/`,
-        });
-        settings.flush();
-        const value = yield settings.get('key1', 'dv');
-        expect(value).toEqual('value1');
-        expect(m1.isDone()).toBeTruthy();
-        settings.flush();
-        const m2 = mockSetting('key1', 'value2');
-        const value2 = yield settings.get('key1', 'dv');
-        expect(value2).toEqual('value2');
-        expect(m2.isDone()).toBeTruthy();
-    }));
-    it('when NODE_ENV === test return the default value', () => __awaiter(void 0, void 0, void 0, function* () {
-        process.env.NODE_ENV = 'test';
-        const settings = new index_1.default({
-            serviceUrl: `http://${serviceUrl}/`,
-        });
-        const value = yield settings.get('key1', 'dv');
-        expect(value).toEqual('dv');
-        process.env.NODE_ENV = 'node-common-test';
-    }));
+            const settings = new index_1.default({
+                serviceUrl: `http://${serviceUrl}/`,
+            });
+            const value = yield settings.get('key1', 'dv');
+            expect(value).toEqual('value1');
+            expect(m.isDone()).toBeTruthy();
+        }));
+        it('Cache from server', () => __awaiter(void 0, void 0, void 0, function* () {
+            const m = mockSetting('key1', 'value1');
+            const settings = new index_1.default({
+                serviceUrl: `http://${serviceUrl}/`,
+            });
+            const value = yield settings.get('key1', 'dv');
+            expect(value).toEqual('value1');
+            expect(m.isDone()).toBeTruthy();
+            const value2 = yield settings.get('key1', 'dv');
+            expect(value2).toEqual('value1');
+        }));
+        it('Use only one request for similar keys', () => __awaiter(void 0, void 0, void 0, function* () {
+            const m = mockSetting('key1EM', 'value1EM');
+            const settings = new index_1.default({
+                serviceUrl: `http://${serviceUrl}/`,
+            });
+            const [value, value2] = yield Promise.all([
+                settings.get('key1EM', 'dv'),
+                settings.get('key1EM', 'dv'),
+            ]);
+            expect(value).toEqual('value1EM');
+            expect(m.isDone()).toBeTruthy();
+            expect(value2).toEqual('value1EM');
+        }));
+        it('Finds with labels', () => __awaiter(void 0, void 0, void 0, function* () {
+            const labels = [{ fleetId: 'uuid' }];
+            const m = mockSetting('key1', 'value1', labels);
+            const settings = new index_1.default({
+                serviceUrl: `http://${serviceUrl}/`,
+            });
+            const value = yield settings.get('key1', 'dv', labels);
+            expect(value).toEqual('value1');
+            expect(m.isDone()).toBeTruthy();
+        }));
+        it('Returns default value when network error', () => __awaiter(void 0, void 0, void 0, function* () {
+            const settings = new index_1.default({
+                serviceUrl: `http://${serviceUrl}/`,
+            });
+            const value = yield settings.get('key1', 'dv', [{ fleetId: 'uuid' }]);
+            expect(value).toEqual('dv');
+        }));
+        it('Throws an error if network error and no default value', () => __awaiter(void 0, void 0, void 0, function* () {
+            const settings = new index_1.default({
+                serviceUrl: `http://${serviceUrl}/`,
+            });
+            const f = () => settings.get('key1', settings.NEVER_DEFAULT_VALUE, [{ fleetId: 'uuid' }]);
+            expect(f())
+                .rejects.toEqual(new Error('Cannot find value from network or cache, default value is set to never'));
+        }));
+        it('Throws an error if network error and no default value and success the next time', (done) => __awaiter(void 0, void 0, void 0, function* () {
+            const settings = new index_1.default({
+                serviceUrl: `http://${serviceUrl}/`,
+            });
+            const f = () => settings.get('key1', settings.NEVER_DEFAULT_VALUE);
+            expect(f())
+                .rejects.toEqual(new Error('Cannot find value from network or cache, default value is set to never'));
+            setTimeout(() => __awaiter(void 0, void 0, void 0, function* () {
+                const m = mockSetting('key1', 'value1');
+                expect(yield settings.get('key1', settings.NEVER_DEFAULT_VALUE)).toEqual('value1');
+                expect(m.isDone());
+                done();
+            }), 100);
+        }));
+        it('Values can be flushed', () => __awaiter(void 0, void 0, void 0, function* () {
+            const m1 = mockSetting('key1', 'value1');
+            const settings = new index_1.default({
+                serviceUrl: `http://${serviceUrl}/`,
+            });
+            settings.flush();
+            const value = yield settings.get('key1', 'dv');
+            expect(value).toEqual('value1');
+            expect(m1.isDone()).toBeTruthy();
+            settings.flush();
+            const m2 = mockSetting('key1', 'value2');
+            const value2 = yield settings.get('key1', 'dv');
+            expect(value2).toEqual('value2');
+            expect(m2.isDone()).toBeTruthy();
+        }));
+        it('when NODE_ENV === test return the default value', () => __awaiter(void 0, void 0, void 0, function* () {
+            process.env.NODE_ENV = 'test';
+            const settings = new index_1.default({
+                serviceUrl: `http://${serviceUrl}/`,
+            });
+            const value = yield settings.get('key1', 'dv');
+            expect(value).toEqual('dv');
+            process.env.NODE_ENV = 'node-common-test';
+        }));
+    });
+    describe('getMultiple', () => {
+        it('when NODE_ENV === test return the default values', () => __awaiter(void 0, void 0, void 0, function* () {
+            process.env.NODE_ENV = 'test';
+            const settings = new index_1.default({
+                serviceUrl: `http://${serviceUrl}/`,
+            });
+            const values = yield settings.getMultiple([
+                {
+                    key: 'key0',
+                    defaultValue: 'defaultValue0',
+                },
+                {
+                    key: 'key1',
+                    defaultValue: 'defaultValue1',
+                },
+                {
+                    key: 'key2',
+                    defaultValue: 'defaultValue2',
+                },
+            ], []);
+            values.map((value, i) => expect(value).toEqual(`defaultValue${i}`));
+            process.env.NODE_ENV = 'node-common-test';
+        }));
+        it('can get multiple settings', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mock = mockMultipleSettings(['key0', 'key1', 'key2'], ['value0', 'value1', 'value2']);
+            const settings = new index_1.default({
+                serviceUrl: `http://${serviceUrl}/`,
+            });
+            const values = yield settings.getMultiple([
+                {
+                    key: 'key0',
+                    defaultValue: 'defaultValue0',
+                },
+                {
+                    key: 'key1',
+                    defaultValue: 'defaultValue1',
+                },
+                {
+                    key: 'key2',
+                    defaultValue: 'defaultValue2',
+                },
+            ], []);
+            expect(mock.isDone()).toBeTruthy();
+            values.forEach((v, index) => {
+                expect(v).toEqual(`value${index}`);
+            });
+        }));
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/settings",
-  "version": "1.0.5-beta-3",
+  "version": "1.0.6",
   "description": "",
   "main": "dist/index.js",
   "scripts": {

package/src/index.test.ts

@@ -15,158 +15,226 @@ const mockSetting = (key: string, value: string | boolean | number | never, labe
   return n.reply(response, { value });
 };
 
-describe('Settings', () => {
-  it('Throws exeption if there is no defualt value', async () => {
-    const settings = new Settings({
-      serviceUrl: `http://${serviceUrl}/`,
+const mockMultipleSettings = (keys: string[], values: string[], response = 200) => {
+  const n = nock(`http://${serviceUrl}`)
+    .get('/api/v1/settings')
+    .query({
+      keys,
+      skipEntityQueryAddition: true,
     });
 
-    expect(settings.get('key1'))
-      .rejects.toEqual(new Error('Can\'t get a key without defaultValue'));
-  });
+  return n.reply(response, values);
+};
 
-  it('Can get 0 as default value', async () => {
-    const settings = new Settings({
-      serviceUrl: `http://${serviceUrl}/`,
+describe('Settings', () => {
+  describe('get', () => {
+    it('Throws exeption if there is no defualt value', async () => {
+      const settings = new Settings({
+        serviceUrl: `http://${serviceUrl}/`,
+      });
+
+      expect(settings.get('key1'))
+        .rejects.toEqual(new Error('Can\'t get a key without defaultValue'));
     });
 
-    expect(await settings.get('key1', 0)).toBe(0);
-  });
+    it('Can get 0 as default value', async () => {
+      const settings = new Settings({
+        serviceUrl: `http://${serviceUrl}/`,
+      });
 
-  it('Can get false as default value', async () => {
-    const settings = new Settings({
-      serviceUrl: `http://${serviceUrl}/`,
+      expect(await settings.get('key1', 0)).toBe(0);
     });
 
-    expect(await settings.get('key1', false)).toBe(false);
-  });
+    it('Can get false as default value', async () => {
+      const settings = new Settings({
+        serviceUrl: `http://${serviceUrl}/`,
+      });
 
-  it('Uses env.SETTING_MS_SERVICE_HOST as service host if no one defined', async () => {
-    const m = mockSetting('key1', 'value1');
-    process.env.SETTING_MS_SERVICE_HOST = serviceUrl;
-    const settings = new Settings();
+      expect(await settings.get('key1', false)).toBe(false);
+    });
 
-    const value = await settings.get('key1', 'dv');
-    expect(value).toEqual('value1');
-    expect(m.isDone()).toBeTruthy();
-    process.env.SETTING_MS_SERVICE_HOST = '';
-  });
+    it('Uses env.SETTING_MS_SERVICE_HOST as service host if no one defined', async () => {
+      const m = mockSetting('key1', 'value1');
+      process.env.SETTING_MS_SERVICE_HOST = serviceUrl;
+      const settings = new Settings();
 
-  it('Get a key from server', async () => {
-    const m = mockSetting('key1', 'value1');
-    const settings = new Settings({
-      serviceUrl: `http://${serviceUrl}/`,
+      const value = await settings.get('key1', 'dv');
+      expect(value).toEqual('value1');
+      expect(m.isDone()).toBeTruthy();
+      process.env.SETTING_MS_SERVICE_HOST = '';
     });
 
-    const value = await settings.get('key1', 'dv');
-    expect(value).toEqual('value1');
-    expect(m.isDone()).toBeTruthy();
-  });
+    it('Get a key from server', async () => {
+      const m = mockSetting('key1', 'value1');
+      const settings = new Settings({
+        serviceUrl: `http://${serviceUrl}/`,
+      });
 
-  it('Cache from server', async () => {
-    const m = mockSetting('key1', 'value1');
-    const settings = new Settings({
-      serviceUrl: `http://${serviceUrl}/`,
+      const value = await settings.get('key1', 'dv');
+      expect(value).toEqual('value1');
+      expect(m.isDone()).toBeTruthy();
     });
 
-    const value = await settings.get('key1', 'dv');
-    expect(value).toEqual('value1');
-    expect(m.isDone()).toBeTruthy();
+    it('Cache from server', async () => {
+      const m = mockSetting('key1', 'value1');
+      const settings = new Settings({
+        serviceUrl: `http://${serviceUrl}/`,
+      });
 
-    const value2 = await settings.get('key1', 'dv');
-    expect(value2).toEqual('value1');
-  });
+      const value = await settings.get('key1', 'dv');
+      expect(value).toEqual('value1');
+      expect(m.isDone()).toBeTruthy();
 
-  it('Use only one request for similar keys', async () => {
-    const m = mockSetting('key1EM', 'value1EM');
-    const settings = new Settings({
-      serviceUrl: `http://${serviceUrl}/`,
+      const value2 = await settings.get('key1', 'dv');
+      expect(value2).toEqual('value1');
     });
 
-    const [value, value2] = await Promise.all([
-      settings.get('key1EM', 'dv'),
-      settings.get('key1EM', 'dv'),
-    ]);
-    expect(value).toEqual('value1EM');
-    expect(m.isDone()).toBeTruthy();
+    it('Use only one request for similar keys', async () => {
+      const m = mockSetting('key1EM', 'value1EM');
+      const settings = new Settings({
+        serviceUrl: `http://${serviceUrl}/`,
+      });
 
-    expect(value2).toEqual('value1EM');
-  });
+      const [value, value2] = await Promise.all([
+        settings.get('key1EM', 'dv'),
+        settings.get('key1EM', 'dv'),
+      ]);
+      expect(value).toEqual('value1EM');
+      expect(m.isDone()).toBeTruthy();
 
-  it('Finds with labels', async () => {
-    const labels = [{ fleetId: 'uuid' }];
-    const m = mockSetting('key1', 'value1', labels);
-    const settings = new Settings({
-      serviceUrl: `http://${serviceUrl}/`,
+      expect(value2).toEqual('value1EM');
     });
 
-    const value = await settings.get('key1', 'dv', labels);
-    expect(value).toEqual('value1');
-    expect(m.isDone()).toBeTruthy();
-  });
+    it('Finds with labels', async () => {
+      const labels = [{ fleetId: 'uuid' }];
+      const m = mockSetting('key1', 'value1', labels);
+      const settings = new Settings({
+        serviceUrl: `http://${serviceUrl}/`,
+      });
 
-  it('Returns default value when network error', async () => {
-    const settings = new Settings({
-      serviceUrl: `http://${serviceUrl}/`,
+      const value = await settings.get('key1', 'dv', labels);
+      expect(value).toEqual('value1');
+      expect(m.isDone()).toBeTruthy();
     });
 
-    const value = await settings.get('key1', 'dv', [{ fleetId: 'uuid' }]);
-    expect(value).toEqual('dv');
-  });
+    it('Returns default value when network error', async () => {
+      const settings = new Settings({
+        serviceUrl: `http://${serviceUrl}/`,
+      });
 
-  it('Throws an error if network error and no default value', async () => {
-    const settings = new Settings({
-      serviceUrl: `http://${serviceUrl}/`,
+      const value = await settings.get('key1', 'dv', [{ fleetId: 'uuid' }]);
+      expect(value).toEqual('dv');
     });
 
-    const f = () => settings.get('key1', settings.NEVER_DEFAULT_VALUE, [{ fleetId: 'uuid' }]);
-    expect(f())
-      .rejects.toEqual(new Error('Cannot find value from network or cache, default value is set to never'));
-  });
+    it('Throws an error if network error and no default value', async () => {
+      const settings = new Settings({
+        serviceUrl: `http://${serviceUrl}/`,
+      });
 
-  it('Throws an error if network error and no default value and success the next time', async (done) => {
-    const settings = new Settings({
-      serviceUrl: `http://${serviceUrl}/`,
+      const f = () => settings.get('key1', settings.NEVER_DEFAULT_VALUE, [{ fleetId: 'uuid' }]);
+      expect(f())
+        .rejects.toEqual(new Error('Cannot find value from network or cache, default value is set to never'));
     });
 
-    const f = () => settings.get('key1', settings.NEVER_DEFAULT_VALUE);
-    expect(f())
-      .rejects.toEqual(new Error('Cannot find value from network or cache, default value is set to never'));
+    it('Throws an error if network error and no default value and success the next time', async (done) => {
+      const settings = new Settings({
+        serviceUrl: `http://${serviceUrl}/`,
+      });
+
+      const f = () => settings.get('key1', settings.NEVER_DEFAULT_VALUE);
+      expect(f())
+        .rejects.toEqual(new Error('Cannot find value from network or cache, default value is set to never'));
+
+      setTimeout(async () => {
+        const m = mockSetting('key1', 'value1');
+        expect(await settings.get('key1', settings.NEVER_DEFAULT_VALUE)).toEqual('value1');
+        expect(m.isDone());
+        done();
+      }, 100);
+    });
 
-    setTimeout(async () => {
-      const m = mockSetting('key1', 'value1');
-      expect(await settings.get('key1', settings.NEVER_DEFAULT_VALUE)).toEqual('value1');
-      expect(m.isDone());
-      done();
-    }, 100);
-  });
+    it('Values can be flushed', async () => {
+      const m1 = mockSetting('key1', 'value1');
+      const settings = new Settings({
+        serviceUrl: `http://${serviceUrl}/`,
+      });
+      settings.flush();
 
-  it('Values can be flushed', async () => {
-    const m1 = mockSetting('key1', 'value1');
-    const settings = new Settings({
-      serviceUrl: `http://${serviceUrl}/`,
-    });
-    settings.flush();
+      const value = await settings.get('key1', 'dv');
+      expect(value).toEqual('value1');
+      expect(m1.isDone()).toBeTruthy();
+
+      settings.flush();
+      const m2 = mockSetting('key1', 'value2');
 
-    const value = await settings.get('key1', 'dv');
-    expect(value).toEqual('value1');
-    expect(m1.isDone()).toBeTruthy();
+      const value2 = await settings.get('key1', 'dv');
+      expect(value2).toEqual('value2');
+      expect(m2.isDone()).toBeTruthy();
+    });
 
-    settings.flush();
-    const m2 = mockSetting('key1', 'value2');
+    it('when NODE_ENV === test return the default value', async () => {
+      process.env.NODE_ENV = 'test';
+      const settings = new Settings({
+        serviceUrl: `http://${serviceUrl}/`,
+      });
 
-    const value2 = await settings.get('key1', 'dv');
-    expect(value2).toEqual('value2');
-    expect(m2.isDone()).toBeTruthy();
+      const value = await settings.get('key1', 'dv');
+      expect(value).toEqual('dv');
+      process.env.NODE_ENV = 'node-common-test';
+    });
   });
-  it('when NODE_ENV === test return the default value', async () => {
-    process.env.NODE_ENV = 'test';
-    const settings = new Settings({
-      serviceUrl: `http://${serviceUrl}/`,
+
+  describe('getMultiple', () => {
+    it('when NODE_ENV === test return the default values', async () => {
+      process.env.NODE_ENV = 'test';
+      const settings = new Settings({
+        serviceUrl: `http://${serviceUrl}/`,
+      });
+
+      const values = await settings.getMultiple([
+        {
+          key: 'key0',
+          defaultValue: 'defaultValue0',
+        },
+        {
+          key: 'key1',
+          defaultValue: 'defaultValue1',
+        },
+        {
+          key: 'key2',
+          defaultValue: 'defaultValue2',
+        },
+      ], []);
+      values.map((value: any, i: number) => expect(value).toEqual(`defaultValue${i}`));
+      process.env.NODE_ENV = 'node-common-test';
     });
 
-    const value = await settings.get('key1', 'dv');
-    expect(value).toEqual('dv');
-    process.env.NODE_ENV = 'node-common-test';
+    it('can get multiple settings', async () => {
+      const mock = mockMultipleSettings(['key0', 'key1', 'key2'], ['value0', 'value1', 'value2']);
+
+      const settings = new Settings({
+        serviceUrl: `http://${serviceUrl}/`,
+      });
+
+      const values = await settings.getMultiple([
+        {
+          key: 'key0',
+          defaultValue: 'defaultValue0',
+        },
+        {
+          key: 'key1',
+          defaultValue: 'defaultValue1',
+        },
+        {
+          key: 'key2',
+          defaultValue: 'defaultValue2',
+        },
+      ], []);
+
+      expect(mock.isDone()).toBeTruthy();
+      values.forEach((v: any, index: number) => {
+        expect(v).toEqual(`value${index}`);
+      });
+    });
   });
 });

package/src/index.ts

@@ -40,7 +40,7 @@ interface GetSettingOption {
   rejectOnFail?: boolean;
 }
 
-class ConnotGetNetworkValueError extends Error {}
+class CannotGetNetworkValueError extends Error {}
 
 class SettingsManager {
   ttl: number;
@@ -121,7 +121,7 @@ class SettingsManager {
     } catch (error) {
       logger.error('Cant get setting from network');
       if (rejectOnFail) {
-        throw new ConnotGetNetworkValueError();
+        throw new CannotGetNetworkValueError();
       }
     }
 
@@ -145,60 +145,51 @@ class SettingsManager {
     labels: LabelsArray,
     { timeout = 5000, rejectOnFail = false } : GetSettingOption = {},
   ): Promise<any> {
-    settingsToGet.map((obj) => {
-      if (typeof obj.defaultValue === 'undefined') {
-        throw new Error(`Missing default value for key ${obj.key}`);
-      }
-    });
-
+    const settingsToReturn = new Map();
+    const settingsToFetch: any[] = [];
     if (process.env.NODE_ENV === 'test') {
       return settingsToGet.map((obj) => obj.defaultValue);
     }
 
-    settingsToGet.map(async (obj) => {
+    settingsToGet.map((obj) => {
       const cacheKey = `${obj.key}_${JSON.stringify(labels)}`;
       const cacheValue = this.settingsCache.get(cacheKey);
-      if (cacheValue !== undefined) {
-        if (waitingToNetwork === cacheValue) {
-          await nextTick();
-          return new Promise((resolve) => {
-            this.networkEvents.once(cacheKey, (networkValue) => {
-              resolve(SettingsManager.readNetworkValue(networkValue, obj.defaultValue));
-            });
-          });
-        }
+      if (cacheValue) {
+        settingsToReturn.set(obj.key, cacheValue);
+      } else {
+        settingsToFetch.push(obj.key);
       }
     });
 
-    settingsToGet.map((obj) => {
-      const cacheKey = `${obj.key}_${JSON.stringify(labels)}`;
-      this.settingsCache.set(cacheKey, waitingToNetwork, this.ttl);
-    });
+    if (settingsToFetch.length > 0) {
+      let values: any[];
+      try {
+        const { data } = await this.network.get('/api/v1/settings', {
+          params: {
+            keys: settingsToFetch,
+            labels,
+            skipEntityQueryAddition: true,
+          },
+          timeout,
+        });
+        values = data;
 
-    let settings;
-    try {
-      const { data } = await this.network.get('/api/v1/settings', {
-        params: {
-          keys: settingsToGet.map((obj) => obj.key),
-          labels,
-        },
-        timeout,
-      });
-      settings = data;
-    } catch (err) {
-      logger.error('Cant get setting from network');
-      if (rejectOnFail) {
-        throw new ConnotGetNetworkValueError();
+        settingsToFetch.map((key, index) => {
+          settingsToReturn.set(key, values[index]);
+        });
+      } catch (err) {
+        logger.error('Cant get setting from network', { err });
+        if (rejectOnFail) {
+          throw new CannotGetNetworkValueError();
+        }
       }
     }
 
-    // eslint-disable-next-line array-callback-return
-    settings.map((setting: any, index: number) => {
-      const cacheKey = `${settingsToGet[index].key}_${JSON.stringify(labels)}`;
-      this.networkEvents.emit(cacheKey, setting);
+    return settingsToGet.map((setting: any) => {
+      const cacheKey = `${setting.key}_${JSON.stringify(labels)}`;
       let returnValue;
       try {
-        returnValue = SettingsManager.readNetworkValue(setting, settingsToGet[index].defaultValue);
+        returnValue = SettingsManager.readNetworkValue(settingsToReturn.get(setting.key), setting.defaultValue);
       } catch (err) {
         this.settingsCache.del(cacheKey);
         throw err;
@@ -206,8 +197,6 @@ class SettingsManager {
       this.settingsCache.set(cacheKey, returnValue, this.ttl);
       return returnValue;
     });
-
-    return settings;
   }
 
   setLocal(key: string, labels: LabelsArray, value: SettingValue) {