@autofleet/settings 1.0.5-beta-2 → 1.0.5

package/dist/index.js

@@ -131,7 +131,7 @@ class SettingsManager {
                 const cacheKey = `${obj.key}_${JSON.stringify(labels)}`;
                 this.settingsCache.set(cacheKey, waitingToNetwork, this.ttl);
             });
-            let settings;
+            let values;
             try {
                 const { data } = yield this.network.get('/api/v1/settings', {
                     params: {
@@ -140,21 +140,20 @@ class SettingsManager {
                     },
                     timeout,
                 });
-                settings = data;
+                values = data.values;
             }
             catch (err) {
-                logger.error('Cant get setting from network');
+                logger.error('Cant get setting from network', { err });
                 if (rejectOnFail) {
                     throw new ConnotGetNetworkValueError();
                 }
             }
-            // 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, index) => {
+                const cacheKey = `${setting.key}_${JSON.stringify(labels)}`;
+                this.networkEvents.emit(cacheKey, values[index]);
                 let returnValue;
                 try {
-                    returnValue = SettingsManager.readNetworkValue(setting, settingsToGet[index].defaultValue);
+                    returnValue = SettingsManager.readNetworkValue(values[index], setting.defaultValue);
                 }
                 catch (err) {
                     this.settingsCache.del(cacheKey);
@@ -163,7 +162,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,187 @@ 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,
+    });
+    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-2",
+  "version": "1.0.5",
   "description": "",
   "main": "dist/index.js",
   "scripts": {

package/src/index.test.ts

@@ -15,158 +15,225 @@ 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,
     });
 
-    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

@@ -175,7 +175,7 @@ class SettingsManager {
       this.settingsCache.set(cacheKey, waitingToNetwork, this.ttl);
     });
 
-    let settings;
+    let values: any[];
     try {
       const { data } = await this.network.get('/api/v1/settings', {
         params: {
@@ -184,21 +184,20 @@ class SettingsManager {
         },
         timeout,
       });
-      settings = data;
+      values = data.values;
     } catch (err) {
-      logger.error('Cant get setting from network');
+      logger.error('Cant get setting from network', { err });
       if (rejectOnFail) {
         throw new ConnotGetNetworkValueError();
       }
     }
 
-    // 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, index: number) => {
+      const cacheKey = `${setting.key}_${JSON.stringify(labels)}`;
+      this.networkEvents.emit(cacheKey, values[index]);
       let returnValue;
       try {
-        returnValue = SettingsManager.readNetworkValue(setting, settingsToGet[index].defaultValue);
+        returnValue = SettingsManager.readNetworkValue(values[index], setting.defaultValue);
       } catch (err) {
         this.settingsCache.del(cacheKey);
         throw err;
@@ -206,8 +205,6 @@ class SettingsManager {
       this.settingsCache.set(cacheKey, returnValue, this.ttl);
       return returnValue;
     });
-
-    return settings;
   }
 
   setLocal(key: string, labels: LabelsArray, value: SettingValue) {