@autofleet/settings 1.0.0

package/.eslintrc.json

@@ -0,0 +1,66 @@
+{
+  "root": true,
+  "env": {
+    "node": true,
+    "jest": true
+  },
+  "extends": [
+    "airbnb-base",
+    "plugin:@typescript-eslint/recommended"
+  ],
+  "rules": {
+    "import/extensions": [
+      "error",
+      "ignorePackages",
+      {
+        "js": "never",
+        "jsx": "never",
+        "ts": "never",
+        "tsx": "never"
+      }
+    ],
+    "@typescript-eslint/no-unused-vars": ["error"],
+    "@typescript-eslint/no-var-requires": ["off"],
+    "@typescript-eslint/camelcase": ["off"],
+    "max-len": ["off"],
+    "@typescript-eslint/explicit-function-return-type": ["off"]
+  },
+  "overrides": [
+    {
+      // enable the rule specifically for TypeScript files
+      "files": ["src/**.js", "src/**.ts"],
+      "rules": {
+        "@typescript-eslint/explicit-function-return-type": ["off"],
+        "@typescript-eslint/no-var-requires": ["off"],
+        "@typescript-eslint/camelcase": ["off"]
+      }
+    }
+  ],
+  "parser": "@typescript-eslint/parser",
+  "parserOptions": {
+    "project": "./tsconfig.json",
+    "sourceType": "module"
+  },
+  "ignorePatterns": ["dist/*", "node_modules/", "jest.config.js", "migrations/*", "newrelic.js"],
+  "plugins": ["@typescript-eslint"],
+  "settings": {
+    "import/extensions": [
+      "error",
+      "ignorePackages",
+      {
+        "js": "never",
+        "jsx": "never",
+        "ts": "never",
+        "tsx": "never"
+      }
+    ],
+    "import/parsers": {
+      "@typescript-eslint/parser": [".ts",".tsx"]
+    },
+    "import/resolver": {
+      "node": {
+        "extensions": [".js",".jsx",".ts",".tsx", ".json"]
+      }
+    }
+  }
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,112 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// eslint-disable-next-line max-classes-per-file
+const dotenv_1 = __importDefault(require("dotenv"));
+const network_1 = __importDefault(require("@autofleet/network"));
+const logger_1 = __importDefault(require("@autofleet/logger"));
+const node_cache_1 = __importDefault(require("node-cache"));
+const events_1 = __importDefault(require("events"));
+const util_1 = __importDefault(require("util"));
+dotenv_1.default.config();
+const nextTick = util_1.default.promisify(process.nextTick);
+const logger = logger_1.default();
+const fiveMinutes = 60 * 5;
+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 SettingsManager {
+    constructor({ serviceUrl, ttl = fiveMinutes } = {}) {
+        const localServiceUrl = findUrl(serviceUrl);
+        this.NEVER_DEFAULT_VALUE = SettingsManager.NEVER_DEFAULT_VALUE;
+        this.ttl = ttl;
+        this.settingsCache = new node_cache_1.default();
+        this.networkEvents = new events_1.default();
+        this.network = new network_1.default({
+            serviceUrl: localServiceUrl,
+        });
+    }
+    static get NEVER_DEFAULT_VALUE() {
+        return 'NEVER_DEFAULT_VALUE';
+    }
+    static readNetworkValue(networkValue, defaultValue) {
+        const returnValue = typeof networkValue !== 'undefined' ? networkValue : defaultValue;
+        if (returnValue === SettingsManager.NEVER_DEFAULT_VALUE) {
+            throw new Error('Cannot find value from network or cache, default value is set to never');
+        }
+        return returnValue;
+    }
+    get(key, defaultValue, labels = [], { timeout = 5000, rejectOnFail = false } = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (typeof defaultValue === 'undefined') {
+                throw new Error('Can\'t get a key without defaultValue');
+            }
+            const cacheKey = `${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, defaultValue));
+                        });
+                    });
+                }
+                return cacheValue;
+            }
+            if (process.env.NODE_ENV === 'test') {
+                return defaultValue;
+            }
+            let networkValue;
+            try {
+                this.settingsCache.set(cacheKey, waitingToNetwork, this.ttl);
+                const networkResponse = yield this.network.get(`/api/v1/settings/get-setting/${key}`, {
+                    params: {
+                        labels,
+                    },
+                    timeout,
+                });
+                networkValue = networkResponse.data.value;
+            }
+            catch (error) {
+                logger.error('Cant get setting from network');
+                if (rejectOnFail) {
+                    throw new ConnotGetNetworkValueError();
+                }
+            }
+            this.networkEvents.emit(cacheKey, networkValue);
+            let returnValue;
+            try {
+                returnValue = SettingsManager.readNetworkValue(networkValue, defaultValue);
+            }
+            catch (e) {
+                this.settingsCache.del(cacheKey);
+                throw e;
+            }
+            this.settingsCache.set(cacheKey, returnValue, this.ttl);
+            return returnValue;
+        });
+    }
+    setLocal(key, labels, value) {
+        const cacheKey = `${key}_${JSON.stringify(labels)}`;
+        this.settingsCache.set(cacheKey, value, this.ttl);
+    }
+    flush() {
+        return this.settingsCache.flushAll();
+    }
+}
+module.exports = SettingsManager;

package/dist/index.test.d.ts

@@ -0,0 +1,4 @@
+declare const nock: any;
+declare const Settings: any;
+declare const serviceUrl = "localhost:8085";
+declare const mockSetting: (key: string, value: string | boolean | number | never, labels?: any, response?: number) => any;

package/dist/index.test.js

@@ -0,0 +1,147 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+const nock = require('nock');
+const Settings = require('./index');
+process.env.NODE_ENV = 'node-common-test';
+const serviceUrl = 'localhost:8085';
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const mockSetting = (key, value, labels = undefined, response = 200) => {
+    const n = nock(`http://${serviceUrl}`)
+        .get(`/api/v1/settings/get-setting/${key}`)
+        .query(labels ? { labels } : undefined);
+    return n.reply(response, { value });
+};
+describe('Settings', () => {
+    it('Throws exeption if there is no defualt value', () => __awaiter(void 0, void 0, void 0, function* () {
+        const settings = new Settings({
+            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 Settings({
+            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 Settings({
+            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 Settings();
+        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 Settings({
+            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 Settings({
+            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 Settings({
+            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 Settings({
+            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 Settings({
+            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 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'));
+    }));
+    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 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(() => __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 Settings({
+            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 Settings({
+            serviceUrl: `http://${serviceUrl}/`,
+        });
+        const value = yield settings.get('key1', 'dv');
+        expect(value).toEqual('dv');
+        process.env.NODE_ENV = 'node-common-test';
+    }));
+});

package/jest.config.js

@@ -0,0 +1,14 @@
+module.exports = {
+  testEnvironment: 'node',
+  roots: ['<rootDir>/src'],
+  transform: {
+    '^.+\\.tsx?$': 'ts-jest',
+  },
+  testRegex: '(/__tests__/.*|(\\.|/)(test|spec))\\.(tsx?$|jsx?$)',
+  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json', 'node'],
+  coverageThreshold: {
+    global: {
+      lines: 75,
+    },
+  },
+}

package/nodemon.json

@@ -0,0 +1,13 @@
+{
+  "ignore": [
+    "**/*.test.ts",
+    "**/*.spec.ts",
+    ".git",
+    "node_modules"
+  ],
+  "watch": [
+    "src"
+  ],
+  "exec": "npm start",
+  "ext": "ts"
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@autofleet/settings",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "start": "ts-node  src/index.ts",
+    "example": "ts-node  src/example.ts",
+    "prepublish": "tsc",
+    "linter": "./node_modules/.bin/eslint .",
+    "test": "jest --forceExit",
+    "coverage": "jest --coverage --forceExit --runInBand && rm -rf ./coverage",
+    "dev": "nodemon"
+  },
+  "dependencies": {
+    "@autofleet/logger": "^1.0.0",
+    "@autofleet/network": "^1.2.1",
+    "@types/jest": "^22.0.0",
+    "bluebird": "^3.7.2",
+    "dotenv": "^8.2.0",
+    "jest": "^22.4.4",
+    "node-cache": "^5.1.2",
+    "nock": "^10.0.2"
+  },
+  "devDependencies": {
+    "@typescript-eslint/eslint-plugin": "^4.8.1",
+    "eslint": "^7.13.0",
+    "eslint-config-airbnb-typescript": "^12.0.0",
+    "eslint-plugin-import": "^2.22.1",
+    "ts-jest": "^25.4.0",
+    "ts-node": "^8.6.2",
+    "typescript": "^3.8.3"
+  },
+  "author": "",
+  "license": "ISC"
+}

package/src/alltypes.d.ts

@@ -0,0 +1,2 @@
+declare module '@autofleet/network';
+declare module '@autofleet/logger';

package/src/index.test.ts

@@ -0,0 +1,171 @@
+const nock = require('nock');
+const Settings = require('./index');
+
+process.env.NODE_ENV = 'node-common-test';
+
+const serviceUrl = 'localhost:8085';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const mockSetting = (key: string, value: string | boolean | number | never, labels: any = undefined, response = 200) => {
+  const n = nock(`http://${serviceUrl}`)
+    .get(`/api/v1/settings/get-setting/${key}`)
+    .query(labels ? { labels } : undefined);
+
+  return n.reply(response, { value });
+};
+
+describe('Settings', () => {
+  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'));
+  });
+
+  it('Can get 0 as default value', async () => {
+    const settings = new Settings({
+      serviceUrl: `http://${serviceUrl}/`,
+    });
+
+    expect(await settings.get('key1', 0)).toBe(0);
+  });
+
+  it('Can get false as default value', async () => {
+    const settings = new Settings({
+      serviceUrl: `http://${serviceUrl}/`,
+    });
+
+    expect(await settings.get('key1', false)).toBe(false);
+  });
+
+  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();
+
+    const value = await settings.get('key1', 'dv');
+    expect(value).toEqual('value1');
+    expect(m.isDone()).toBeTruthy();
+    process.env.SETTING_MS_SERVICE_HOST = '';
+  });
+
+  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();
+  });
+
+  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 value2 = await settings.get('key1', 'dv');
+    expect(value2).toEqual('value1');
+  });
+
+  it('Use only one request for similar keys', async () => {
+    const m = mockSetting('key1EM', 'value1EM');
+    const settings = new Settings({
+      serviceUrl: `http://${serviceUrl}/`,
+    });
+
+    const [value, value2] = await 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', async () => {
+    const labels = [{ fleetId: 'uuid' }];
+    const m = mockSetting('key1', 'value1', labels);
+    const settings = new Settings({
+      serviceUrl: `http://${serviceUrl}/`,
+    });
+
+    const value = await settings.get('key1', 'dv', labels);
+    expect(value).toEqual('value1');
+    expect(m.isDone()).toBeTruthy();
+  });
+
+  it('Returns default value when network error', async () => {
+    const settings = new Settings({
+      serviceUrl: `http://${serviceUrl}/`,
+    });
+
+    const value = await settings.get('key1', 'dv', [{ fleetId: 'uuid' }]);
+    expect(value).toEqual('dv');
+  });
+
+  it('Throws an error if network error and no default value', async () => {
+    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'));
+  });
+
+  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);
+  });
+
+  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 value2 = await settings.get('key1', 'dv');
+    expect(value2).toEqual('value2');
+    expect(m2.isDone()).toBeTruthy();
+  });
+  it('when NODE_ENV === test return the default value', async () => {
+    process.env.NODE_ENV = 'test';
+    const settings = new Settings({
+      serviceUrl: `http://${serviceUrl}/`,
+    });
+
+    const value = await settings.get('key1', 'dv');
+    expect(value).toEqual('dv');
+    process.env.NODE_ENV = 'node-common-test';
+  });
+});

package/src/index.ts

@@ -0,0 +1,148 @@
+// eslint-disable-next-line max-classes-per-file
+import dotenv from 'dotenv';
+import Network from '@autofleet/network';
+import Logger from '@autofleet/logger';
+import NodeCache from 'node-cache';
+import EventEmitter from 'events';
+import util from 'util';
+
+dotenv.config();
+
+const nextTick = util.promisify(process.nextTick);
+const logger = Logger();
+
+const fiveMinutes = 60 * 5;
+const waitingToNetwork = 'waitingToNetwork';
+
+const findUrl = (serviceUrl?: string) => 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/');
+
+interface SettingsClassOptions {
+  serviceUrl?: string;
+  ttl?: number;
+}
+
+type SettingValue = string | boolean | number | never;
+
+interface Label {
+  businessModelId?: string;
+  demandSourceId?: string;
+  fleetId?: string;
+}
+
+type LabelsArray = Label[];
+
+interface GetSettingOption {
+  timeout?: number;
+  rejectOnFail?: boolean;
+}
+
+class ConnotGetNetworkValueError extends Error {}
+
+class SettingsManager {
+  ttl: number;
+
+  settingsCache: NodeCache;
+
+  networkEvents: EventEmitter;
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  network: any;
+
+  NEVER_DEFAULT_VALUE: string;
+
+  static get NEVER_DEFAULT_VALUE() {
+    return 'NEVER_DEFAULT_VALUE';
+  }
+
+  static readNetworkValue(networkValue: SettingValue, defaultValue: SettingValue) {
+    const returnValue = typeof networkValue !== 'undefined' ? networkValue : defaultValue;
+
+    if (returnValue === SettingsManager.NEVER_DEFAULT_VALUE) {
+      throw new Error('Cannot find value from network or cache, default value is set to never');
+    }
+
+    return returnValue;
+  }
+
+  constructor({ serviceUrl, ttl = fiveMinutes }:SettingsClassOptions = {}) {
+    const localServiceUrl = findUrl(serviceUrl);
+
+    this.NEVER_DEFAULT_VALUE = SettingsManager.NEVER_DEFAULT_VALUE;
+    this.ttl = ttl;
+    this.settingsCache = new NodeCache();
+    this.networkEvents = new EventEmitter();
+    this.network = new Network({
+      serviceUrl: localServiceUrl,
+    });
+  }
+
+  async get(
+    key: SettingValue,
+    defaultValue: SettingValue,
+    labels:LabelsArray = [],
+    { timeout = 5000, rejectOnFail = false } : GetSettingOption = {},
+  ) {
+    if (typeof defaultValue === 'undefined') {
+      throw new Error('Can\'t get a key without defaultValue');
+    }
+
+    const cacheKey = `${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, defaultValue));
+          });
+        });
+      }
+      return cacheValue;
+    }
+
+    if (process.env.NODE_ENV === 'test') {
+      return defaultValue;
+    }
+
+    let networkValue;
+    try {
+      this.settingsCache.set(cacheKey, waitingToNetwork, this.ttl);
+      const networkResponse = await this.network.get(`/api/v1/settings/get-setting/${key}`, {
+        params: {
+          labels,
+        },
+        timeout,
+      });
+      networkValue = networkResponse.data.value;
+    } catch (error) {
+      logger.error('Cant get setting from network');
+      if (rejectOnFail) {
+        throw new ConnotGetNetworkValueError();
+      }
+    }
+
+    this.networkEvents.emit(cacheKey, networkValue);
+    let returnValue;
+    try {
+      returnValue = SettingsManager.readNetworkValue(networkValue, defaultValue);
+    } catch (e) {
+      this.settingsCache.del(cacheKey);
+      throw e;
+    }
+    this.settingsCache.set(cacheKey, returnValue, this.ttl);
+    return returnValue;
+  }
+
+  setLocal(key: string, labels: LabelsArray, value: SettingValue) {
+    const cacheKey = `${key}_${JSON.stringify(labels)}`;
+    this.settingsCache.set(cacheKey, value, this.ttl);
+  }
+
+  flush() {
+    return this.settingsCache.flushAll();
+  }
+}
+
+module.exports = SettingsManager;

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "target": "es6",
+    "module": "commonjs",
+    "declaration": true,
+    "outDir": "./dist",
+    "strict": true,
+    "esModuleInterop": true
+  }
+}