@chainlink/external-adapter-framework 0.0.6 → 0.0.8

package/validation/validator.js

@@ -0,0 +1,303 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Validator = void 0;
+const error_1 = require("./error");
+const input_params_1 = require("./input-params");
+const util_1 = require("../util");
+const preset_tokens_json_1 = __importDefault(require("./preset-tokens.json"));
+// Don't want to get requester in just yet, only copying the static method 'errored'
+const requesterErrored = (jobRunID = '1', error = undefined, statusCode = 500, feedID = undefined) => {
+    if (error instanceof error_1.AdapterError) {
+        error.jobRunID = jobRunID;
+        if (feedID) {
+            error.feedID = feedID;
+        }
+        return error.toJSONResponse();
+    }
+    if (error instanceof Error) {
+        return new error_1.AdapterError({
+            jobRunID,
+            statusCode,
+            message: error.message,
+            cause: error,
+            feedID,
+        }).toJSONResponse();
+    }
+    return new error_1.AdapterError({ jobRunID, statusCode, message: error, feedID }).toJSONResponse();
+};
+class Validator {
+    constructor(input = { id: '1', data: {} }, inputConfigs = {}, inputOptions = {}, validatorOptions = {}) {
+        // OverrideSymbol = (adapter: string, symbol?: string | string[]): string | string[] => {
+        //   Const defaultSymbol = symbol || this.validated.data.base
+        //   If (!defaultSymbol) this.throwInvalid(`Required parameter not supplied: base`)
+        //   // TODO: Will never be reached, because the presetSymbols are used as default overrides
+        //   If (!this.validated.overrides) return defaultSymbol
+        //   If (!Array.isArray(defaultSymbol))
+        //     Return (
+        //       This.validated.overrides.get(adapter.toLowerCase())?.get(defaultSymbol.toLowerCase()) ||
+        //       DefaultSymbol
+        //     )
+        //   Const multiple: string[] = []
+        //   For (const sym of defaultSymbol) {
+        //     Const overrided = this.validated.overrides.get(adapter.toLowerCase())?.get(sym.toLowerCase())
+        //     If (!overrided) multiple.push(sym)
+        //     Else multiple.push(overrided)
+        //   }
+        //   Return multiple
+        // }
+        // OverrideToken = (symbol: string, network = 'ethereum'): string | undefined => {
+        //   Return this.validated.tokenOverrides?.get(network.toLowerCase())?.get(symbol.toLowerCase())
+        // }
+        // OverrideIncludes = (from: string, to: string): IncludePair | undefined => {
+        //   // Search through `presetIncludes` to find matching override for adapter and to/from pairing.
+        //   Const pairs = (
+        //     This.validated.includes?.filter(
+        //       (val: string | Includes) => typeof val !== 'string',
+        //     ) as Includes[]
+        //   ).filter(
+        //     (pair) =>
+        //       Pair.from.toLowerCase() === from.toLowerCase() &&
+        //       Pair.to.toLowerCase() === to.toLowerCase(),
+        //   )
+        //   If (!pairs || !pairs[0] || !pairs[0].includes || !pairs[0].includes[0]) {
+        //     Return
+        //   }
+        //   Return pairs[0].includes[0]
+        // }
+        // OverrideReverseLookup = (adapter: string, type: OverrideType, symbol: string): string => {
+        //   Const overrides: Map<string, string> | undefined = this.validated?.[type]?.get(
+        //     Adapter.toLowerCase(),
+        //   )
+        //   If (!overrides) return symbol
+        //   Let originalSymbol: string | undefined
+        //   Overrides.forEach((overridden, original) => {
+        //     If (overridden.toLowerCase() === symbol.toLowerCase()) originalSymbol = original
+        //   })
+        //   Return originalSymbol || symbol
+        // }
+        this.formatOverride = (param) => {
+            const _throwInvalid = () => this.throwInvalid(`Parameter supplied with wrong format: "override"`);
+            if (!(0, util_1.isObject)(param)) {
+                _throwInvalid();
+            }
+            const _isValid = Object.values(param).every(util_1.isObject);
+            if (!_isValid) {
+                _throwInvalid();
+            }
+            const _keyToLowerCase = (entry) => {
+                return [entry[0].toLowerCase(), entry[1]];
+            };
+            return new Map(Object.entries(param)
+                .map(_keyToLowerCase)
+                .map(([key, value]) => [key, new Map(Object.entries(value).map(_keyToLowerCase))]));
+        };
+        this.formatIncludeOverrides = (param) => {
+            const _throwInvalid = () => this.throwInvalid(`Parameter supplied with wrong format: "includes"`);
+            if (!(0, util_1.isArray)(param)) {
+                _throwInvalid();
+            }
+            const _isValid = Object.values(param).every((val) => (0, util_1.isObject)(val) || typeof val === 'string');
+            if (!_isValid) {
+                _throwInvalid();
+            }
+            return param;
+        };
+        this.throwInvalid = (message) => {
+            throw new error_1.AdapterError({ jobRunID: this.validated.id, statusCode: 400, message });
+        };
+        this.input = { ...input };
+        if (!this.input.id) {
+            this.input.id = '1';
+        } // TODO Please remove these once "no any" strict typing is enabled
+        if (!this.input.data) {
+            this.input.data = {};
+        }
+        this.inputConfigs = { ...input_params_1.baseInputParameters, ...inputConfigs };
+        this.inputOptions = { ...inputOptions };
+        this.validatorOptions = {
+            shouldThrowError: true,
+            includes: [],
+            overrides: {},
+            ...validatorOptions,
+        };
+        this.validated = { id: this.input.id, data: {} };
+        this.validateInput();
+        this.validateOverrides('overrides', this.validatorOptions.overrides);
+        this.validateOverrides('tokenOverrides', preset_tokens_json_1.default);
+        this.validateIncludeOverrides();
+        this.checkDuplicateInputParams(inputConfigs);
+    }
+    validateInput() {
+        try {
+            for (const key in this.inputConfigs) {
+                this.validateObjectParam(key, this.validatorOptions.shouldThrowError);
+            }
+        }
+        catch (e) {
+            this.parseError(e);
+        }
+    }
+    validateOverrides(path, preset) {
+        try {
+            if (!this.input.data?.[path]) {
+                this.validated[path] = this.formatOverride(preset);
+                return;
+            }
+            this.validated[path] = this.formatOverride({ ...preset, ...this.input.data[path] });
+        }
+        catch (e) {
+            this.parseError(e);
+        }
+    }
+    checkDuplicateInputParams(inputConfig) {
+        let aliases = [];
+        for (const key in inputConfig) {
+            const param = inputConfig[key];
+            if (Array.isArray(param)) {
+                aliases = aliases.concat(param);
+            }
+            else if (typeof inputConfig === 'boolean') {
+                return;
+            }
+            else {
+                aliases.push(key);
+                if (typeof param === 'object' && 'aliases' in param && Array.isArray(param.aliases)) {
+                    aliases = aliases.concat(param.aliases);
+                }
+            }
+        }
+        if (aliases.length !== new Set(aliases).size) {
+            this.throwInvalid('Duplicate Input Aliases');
+        }
+    }
+    validateIncludeOverrides() {
+        try {
+            this.validated.includes = this.formatIncludeOverrides([
+                ...(Array.isArray(this.input.data?.includes) ? this.input.data.includes : []),
+                ...(this.validatorOptions.includes || []),
+            ]);
+        }
+        catch (e) {
+            this.parseError(e);
+        }
+    }
+    parseError(error) {
+        if (!(error instanceof Error)) {
+            return;
+        }
+        const message = 'Error validating input.';
+        if (error instanceof error_1.AdapterError) {
+            this.error = error;
+        }
+        else {
+            this.error = new error_1.AdapterError({
+                jobRunID: this.validated.id,
+                statusCode: 400,
+                message,
+                cause: error,
+            });
+        }
+        this.errored = requesterErrored(this.validated.id, this.error);
+        if (this.validatorOptions.shouldThrowError) {
+            throw this.error;
+        }
+    }
+    validateObjectParam(key, shouldThrowError = true) {
+        const inputConfig = this.inputConfigs[key];
+        const usedKey = this.getUsedKey(key, inputConfig.aliases ?? []);
+        const param = usedKey
+            ? this.input.data[usedKey] ?? inputConfig.default
+            : inputConfig.default;
+        if (shouldThrowError) {
+            const paramIsDefined = !(param === undefined || param === null || param === '');
+            if (inputConfig.required && !paramIsDefined) {
+                this.throwInvalid(`Required parameter ${key} must be non-null and non-empty`);
+            }
+            if (paramIsDefined) {
+                if (inputConfig.type) {
+                    const primitiveTypes = ['boolean', 'number', 'bigint', 'string'];
+                    if (![...primitiveTypes, 'array', 'object'].includes(inputConfig.type)) {
+                        this.throwInvalid(`${key} parameter has unrecognized type ${inputConfig.type}`);
+                    }
+                    if (primitiveTypes.includes(inputConfig.type) && typeof param !== inputConfig.type) {
+                        this.throwInvalid(`${key} parameter must be of type ${inputConfig.type}`);
+                    }
+                    if (inputConfig.type === 'array' && (!Array.isArray(param) || param.length === 0)) {
+                        this.throwInvalid(`${key} parameter must be a non-empty array`);
+                    }
+                    if (inputConfig.type === 'object' &&
+                        (!param ||
+                            Array.isArray(param) ||
+                            typeof param !== inputConfig.type ||
+                            Object.keys(param).length === 0)) {
+                        this.throwInvalid(`${key} parameter must be an object with at least one property`);
+                    }
+                }
+                // If (inputConfig.options) {
+                //   Const tolcase = (o: any) => (typeof o === 'string' ? o.toLowerCase() : o)
+                //   Const formattedOptions = inputConfig.options.map(tolcase)
+                //   Const formattedParam = tolcase(param)
+                //   If (!formattedOptions.includes(formattedParam))
+                //     This.throwInvalid(
+                //       `${key} parameter '${formattedParam}' is not in the set of available options: ${formattedOptions.join(
+                //         ',',
+                //       )}`,
+                //     )
+                // }
+                // For (const dependency of inputConfig.dependsOn ?? []) {
+                //   Const usedDependencyKey = this.getUsedKey(
+                //     Dependency,
+                //     (this.inputConfigs[dependency] as InputParameter).aliases ?? [],
+                //   )
+                //   If (!usedDependencyKey) this.throwInvalid(`${key} dependency ${dependency} not supplied`)
+                // }
+                // For (const exclusive of inputConfig.exclusive ?? []) {
+                //   Const usedExclusiveKey = this.getUsedKey(
+                //     Exclusive,
+                //     (this.inputConfigs[exclusive] as InputParameter).aliases ?? [],
+                //   )
+                //   If (usedExclusiveKey)
+                //     This.throwInvalid(`${key} cannot be supplied concurrently with ${exclusive}`)
+                // }
+            }
+        }
+        this.validated.data[key] = param;
+    }
+    validateOptionalParam(param, key, options) {
+        if (param && options) {
+            if (!Array.isArray(options)) {
+                this.throwInvalid(`Parameter options for ${key} must be of an Array type`);
+            }
+            if (!options.includes(param)) {
+                this.throwInvalid(`${param} is not a supported ${key} option. Must be one of ${options}`);
+            }
+        }
+        this.validated.data[key] = param;
+    }
+    validateRequiredParam(param, key, options) {
+        if (typeof param === 'undefined' || param === '') {
+            this.throwInvalid(`Required parameter not supplied: ${key}`);
+        }
+        if (options) {
+            if (!Array.isArray(options)) {
+                this.throwInvalid(`Parameter options for ${key} must be of an Array type`);
+            }
+            if (!options.includes(param)) {
+                this.throwInvalid(`${param} is not a supported ${key} option. Must be one of ${options.join(' || ')}`);
+            }
+        }
+        this.validated.data[key] = param;
+    }
+    getUsedKey(key, keyArray) {
+        const comparisonArray = [...keyArray];
+        if (!comparisonArray.includes(key)) {
+            comparisonArray.push(key);
+        }
+        const inputParamKeys = Object.keys(this.input.data);
+        return inputParamKeys.find((k) => comparisonArray.includes(k));
+    }
+}
+exports.Validator = Validator;

package/.c8rc.json

@@ -1,3 +0,0 @@
-{
-  "reporter": ["lcov", "text"]
-}

package/.eslintignore

@@ -1,9 +0,0 @@
-# don't ever lint node_modules
-node_modules
-# don't lint build output (make sure it's set to your correct build folder name)
-dist
-# don't lint coverage output
-coverage
-
-.yarn
-.vscode

package/.eslintrc.js

@@ -1,96 +0,0 @@
-// https://github.com/typescript-eslint/typescript-eslint/blob/master/docs/getting-started/linting/README.md
-module.exports = {
-  root: true,
-  parser: '@typescript-eslint/parser',
-  plugins: ['@typescript-eslint', 'eslint-plugin-tsdoc'],
-  extends: ['eslint:recommended', 'plugin:@typescript-eslint/recommended', 'prettier'],
-  rules: {
-    'tsdoc/syntax': 'warn',
-
-    // Problems
-    'array-callback-return': [
-      'error',
-      {
-        allowImplicit: false,
-        checkForEach: true,
-      },
-    ],
-    'no-constant-binary-expression': 'error',
-    'no-constructor-return': 'error',
-    'no-duplicate-imports': 'error',
-    'no-promise-executor-return': 'error',
-    'no-self-compare': 'error',
-    'no-template-curly-in-string': 'error',
-    'no-unmodified-loop-condition': 'error',
-    'no-unreachable-loop': 'error',
-    'no-unused-private-class-members': 'error',
-    'require-atomic-updates': 'error',
-
-    // Suggestions
-    'capitalized-comments': ['error', 'always', { ignoreConsecutiveComments: true }],
-    complexity: ['error', 25], // TODO: Should be lower (15?), but validator has complex methods
-    curly: 'error',
-    'default-case-last': 'error',
-    'default-param-last': 'error',
-    eqeqeq: ['error', 'smart'],
-    'func-names': 'error',
-    'func-style': ['error', 'declaration', { allowArrowFunctions: true }],
-    'grouped-accessor-pairs': ['error', 'getBeforeSet'],
-    'max-depth': ['error', 4], // TODO: Should be lower (3), but validator has complex methods
-    'max-nested-callbacks': ['error', 2],
-    'max-params': ['error', 4], // TODO: Should be lower (3), but validator has complex methods,
-    'new-cap': ['error', { newIsCapExceptions: ['ctor'] }],
-    'no-caller': 'error',
-    'no-confusing-arrow': [
-      'error',
-      {
-        allowParens: true,
-      },
-    ],
-    'no-console': ['warn'], // We want this to debug, but the check workflow should accept no warns
-    'no-div-regex': 'error',
-    'no-eval': 'error',
-    'no-extend-native': 'error',
-    'no-extra-bind': 'error',
-    'no-extra-label': 'error',
-    'no-extra-semi': 'error',
-    'no-floating-decimal': 'error',
-    'no-implied-eval': 'error',
-    'no-invalid-this': 'error',
-    'no-labels': 'error',
-    'no-lonely-if': 'error',
-    'no-multi-assign': 'error',
-    'no-multi-str': 'error',
-    'no-nested-ternary': 'error',
-    'no-new': 'error',
-    'no-new-func': 'error',
-    'no-new-object': 'error',
-    'no-new-wrappers': 'error',
-    'no-param-reassign': 'error',
-    'no-proto': 'error',
-    'no-return-assign': 'error',
-    'no-return-await': 'error',
-    'no-sequences': 'error',
-    'no-shadow': 'off',
-    '@typescript-eslint/no-shadow': 'error', // https://stackoverflow.com/questions/63961803/eslint-says-all-enums-in-typescript-app-are-already-declared-in-the-upper-scope
-    'no-unneeded-ternary': 'error',
-    'no-useless-call': 'error',
-    'no-useless-computed-key': 'error',
-    'no-useless-concat': 'error',
-    'no-useless-rename': 'error',
-    'no-var': 'error',
-    'operator-assignment': ['error', 'always'],
-    'prefer-arrow-callback': 'error',
-    'prefer-const': 'error',
-    'prefer-exponentiation-operator': 'error',
-    'prefer-object-spread': 'error',
-    'prefer-promise-reject-errors': 'error',
-    'prefer-regex-literals': 'error',
-    'prefer-rest-params': 'error',
-    'prefer-spread': 'error',
-    'prefer-template': 'error',
-    'spaced-comment': ['error', 'always'],
-    'symbol-description': 'error',
-    yoda: 'error',
-  },
-}

package/.github/README.MD

@@ -1,17 +0,0 @@
-# Github workflows for EAv3 Framework
-
-**Please note that this work is in progress. The README may not be accurate**
-
-## Overview
-This directory contains a basic GitHub workflow that builds, tests, and ultimately publishes the EAv3 Framework to NPM
-1. Setup (caches dependencies to speed up other steps)
-2. Build/Prepare/Preflight (all the following happen at the same time)
-   1. yarn build => publish artifact of build
-   2. yarn lint
-   3. yarn test
-3. Publish (currently unimplemented)
-
-### Some steps that still need to be added in:
-1. Check that changelog has an entry matching the current version in package.json
-2. Check if a package is already published to NPM, and DON'T overwrite it unless a parameter explicitly allowing an overwrite has been passed
-3. npm-check step that produces a report as an artifact

package/.github/actions/setup/action.yaml

@@ -1,13 +0,0 @@
-name: 'Setup'
-description: 'Sets up the project, installs dependencies, and builds'
-runs:
-  using: 'composite'
-  steps:
-    - uses: actions/setup-node@v3
-      with:
-        node-version: 16.x
-        registry-url: https://registry.npmjs.org
-        always-auth: true
-        cache: yarn
-    - run: yarn install --frozen-lockfile
-      shell: bash

package/.github/workflows/main.yaml

@@ -1,39 +0,0 @@
-# This is the entry point for CI. It will setup the application, then run lint, test, and eventually publish if not the master or main branch
-name: 'Main'
-on:
-  push:
-    branches:
-      - master
-  pull_request: ~
-
-jobs:
-  setup: # Load the dependencies cache for all jobs
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - uses: ./.github/actions/setup
-  build:
-    needs: setup
-    runs-on: ubuntu-latest
-    concurrency: build-${{ github.ref}}
-    steps:
-      - uses: actions/checkout@v3
-      - uses: ./.github/actions/setup
-      - run: yarn build
-  lint:
-    needs: setup
-    runs-on: ubuntu-latest
-    concurrency: lint-${{ github.ref }}
-    steps:
-      - uses: actions/checkout@v3
-      - uses: ./.github/actions/setup
-      - run: yarn lint
-      - run: yarn prettier --check **/*.{ts,md}
-  test:
-    needs: setup
-    concurrency: test-${{ github.ref }}
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - uses: ./.github/actions/setup
-      - run: yarn test

package/.github/workflows/publish.yaml

@@ -1,17 +0,0 @@
-# This is the entry point for CI. It will setup the application, then run lint, test, and eventually publish if not the master or main branch
-name: 'Publish'
-on:
-  workflow_dispatch:
-  push:
-    branches:
-      - master
-jobs:
-  publish: # Load the dependencies cache for all jobs
-    runs-on: ubuntu-latest
-    environment: main
-    steps:
-      - uses: actions/checkout@v3
-      - uses: ./.github/actions/setup
-      - run: npm publish --access restricted #scoped packages are restricted by default, but this is set because not all branches currently have a scoped package name
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/.prettierignore

@@ -1,13 +0,0 @@
-# don't ever lint node_modules
-node_modules
-# don't lint build output (make sure it's set to your correct build folder name)
-dist
-# don't lint nyc coverage output
-coverage
-test-payload.json
-.yarn
-.vscode
-.pnp.cjs
-.pnp.loader.mjs
-
-packages/k6/k8s/templates

package/README.md

@@ -1,103 +0,0 @@
-# EA Framework v3
-
-External adapters and its core framework serve as middleware to facilitate connections between Chainlink Nodes and Data Providers (DP). Their main purpose is threefold:
-
-- Abstract provider specific details, specifically:
-  - Transport (REST, WebSockets, RPC, SSE, etc.)
-  - Authentication (login flows, keys)
-  - Accept normalized request payloads and translate into the provider's interface (this also includes things like symbols/tickers)
-  - Parse provider responses into the desired data points (e.g. price from crypto endpoint)
-- Make the overall system more efficient by using as few resources (e.g. API credits, networking traffic, CPU usage) as possible to fetch data, achieved by features like:
-  - Caching: since DPs update data at various times and a request to their API incurs a certain latency, EAs keep a cache of values to
-    - Provide responses to the Chainlink Nodes as quickly as possible
-    - Communicate with DPs only when necessary
-  - Cache Warming: in order to make as many of the requests to EAs be fulfilled from the cache, EAs fetch values from DPs asynchronously to keep the local ones fresh.
-  - Batching: the CL Node requests feeds individually, but it's common for DPs to provide batch endpoints to get many data points at once. With Batching, EAs keep track of incoming requests and consolidate them into one batched request.
-  - Rate limiting: the EA framework additionally checks request rates (frequency) to make sure they fall within acceptable limits (like quotas for the DP's API, or adjusting based on the NOP's API tier).
-- Perform off chain computations (think aggregations, indexing, or any sort of data processing)
-
-By providing a framework that gives users easy access to those features, we reduce the complexity required for Nodes to communicate with DPs since by using EAs there is only one standardized way to do so, while at the same time optimizing said communication so it's as resource efficient as possible. It also makes internal and external development easier and faster, by serving as a strict guideline to implement and add new providers.
-
-## Qs
-
-- Store entire response in cache?
-- Check for valid result in adapter response?
-
-## Env vars
-
-These are all existing env vars, marked DONE if they have been ported to this version, or N/A if the new version disregards them altogether.
-
-| Name                                       | State | Comments                                                     |
-| :----------------------------------------- | :---: | :----------------------------------------------------------- |
-| API_TIMEOUT                                |  N/A  | Only used for WS with handler.noHTtp = true                  |
-| BASE_URL                                   |   √   |                                                              |
-| CACHE_ENABLED                              |  N/A  | Cache is integral to this fw, not including this for now     |
-| CACHE_KEY_IGNORED_PROPS                    |  ??   | Do we want this to be available in v3. Used for feed id      |
-| CACHE_KEY_GROUP                            |  ??   | Dunno if this applies to this fw                             |
-| CACHE_MAX_AGE                              |   √   |                                                              |
-| CACHE_MAX_ITEMS                            |   -   | Should add when replacing obj in local impl with LRU package |
-| CACHE_MIN_AGE                              |   -   | Used for rate limiting                                       |
-| CACHE_REDIS_CONNECTION_TIMEOUT             |   -   | TODO: Redis                                                  |
-| CACHE_REDIS_HOST                           |   -   | TODO: Redis                                                  |
-| CACHE_REDIS_MAX_QUEUED_ITEMS               |   -   | TODO: Redis                                                  |
-| CACHE_REDIS_MAX_RECONNECT_COOLDOWN         |   -   | TODO: Redis                                                  |
-| CACHE_REDIS_PASSWORD                       |   -   | TODO: Redis                                                  |
-| CACHE_REDIS_PATH                           |   -   | TODO: Redis                                                  |
-| CACHE_REDIS_PORT                           |   -   | TODO: Redis                                                  |
-| CACHE_REDIS_TIMEOUT                        |   -   | TODO: Redis                                                  |
-| CACHE_REDIS_URL                            |   -   | TODO: Redis                                                  |
-| CACHE_TYPE                                 |   -   | TODO: Cache factory                                          |
-| CACHE_UPDATE_AGE_ON_GET                    |  N/A  | No longer used in EA currently, apparently                   |
-| DEBUG                                      |       |                                                              |
-| DEFAULT_WS_HEARTBEAT_INTERVAL              |       |                                                              |
-| EA_HOST                                    |       |                                                              |
-| EA_PORT                                    |   √   |                                                              |
-| ENV_ADAPTER_URL                            |       |                                                              |
-| ENV_API_ENDPOINT                           |       |                                                              |
-| ENV_API_KEY                                |       |                                                              |
-| ENV_API_TIMEOUT                            |       |                                                              |
-| ENV_API_VERBOSE                            |       |                                                              |
-| ENV_WS_API_ENDPOINT                        |       |                                                              |
-| ENV_WS_API_KEY                             |       |                                                              |
-| ERROR_CAPACITY                             |       |                                                              |
-| EXPERIMENTAL_METRICS_ENABLED               |   √   | Maintaining for backwards compatibility. Defaults to true    |
-| LEGACY_ENV_ADAPTER_URL                     |       |                                                              |
-| LOG_LEVEL                                  |       |                                                              |
-| METRICS_ENABLED                            |   √   | Defaults to true                                             |
-| METRICS_NAME                               |   √   |                                                              |
-| METRICS_PORT                               |   √   |                                                              |
-| METRICS_USE_BASE_URL                       |   √   |                                                              |
-| NODE_ENV                                   |       |                                                              |
-| npm_package_version                        |       |                                                              |
-| RATE_LIMIT_API_TIER                        |       |                                                              |
-| RATE_LIMIT_CAPACITY                        |       |                                                              |
-| RATE_LIMIT_CAPACITY_MINUTE                 |       |                                                              |
-| RATE_LIMIT_CAPACITY_SECOND                 |       |                                                              |
-| RATE_LIMIT_ENABLED                         |       |                                                              |
-| RECORD                                     |       |                                                              |
-| REQUEST_COALESCING_ENABLED                 |       |                                                              |
-| REQUEST_COALESCING_ENTROPY_MAX             |       |                                                              |
-| REQUEST_COALESCING_INTERVAL                |       |                                                              |
-| REQUEST_COALESCING_INTERVAL_COEFFICIENT    |       |                                                              |
-| REQUEST_COALESCING_INTERVAL_MAX            |       |                                                              |
-| REQUEST_COALESCING_MAX_RETRIES             |       |                                                              |
-| RETRY                                      |       |                                                              |
-| SERVER_RATE_LIMIT_MAX                      |       |                                                              |
-| SERVER_SLOW_DOWN_AFTER_FACTOR              |       |                                                              |
-| SERVER_SLOW_DOWN_DELAY_MS                  |       |                                                              |
-| TIMEOUT                                    |       |                                                              |
-| WARMUP_ENABLED                             |       |                                                              |
-| WARMUP_INTERVAL                            |       |                                                              |
-| WARMUP_SUBSCRIPTION_TTL                    |       |                                                              |
-| WARMUP_UNHEALTHY_THRESHOLD                 |       |                                                              |
-| WS_CONNECTION_KEY                          |       |                                                              |
-| WS_CONNECTION_LIMIT                        |       |                                                              |
-| WS_CONNECTION_RETRY_DELAY                  |       |                                                              |
-| WS_CONNECTION_RETRY_LIMIT                  |       |                                                              |
-| WS_CONNECTION_TTL                          |       |                                                              |
-| WS_ENABLED                                 |  N/A  | Shouldn't be part of this fw                                 |
-| WS_SUBSCRIPTION_LIMIT                      |       |                                                              |
-| WS_SUBSCRIPTION_PRIORITY_LIST              |       |                                                              |
-| WS_SUBSCRIPTION_TTL                        |       |                                                              |
-| WS_SUBSCRIPTION_UNRESPONSIVE_TTL           |       |                                                              |
-| WS_TIME_UNTIL_HANDLE_NEXT_MESSAGE_OVERRIDE |       |                                                              |

package/docker-compose.yaml

@@ -1,35 +0,0 @@
-# Very basic stack to demonstrate horizontal scaling
-services:
-  redis:
-    image: redis
-    container_name: redis
-
-  coingecko-reader:
-    image: node:alpine
-    ports:
-      - 8080
-    deploy:
-      mode: replicated
-      replicas: 2
-    environment:
-      - DISABLE_BACKGROUND_EXECUTOR=true
-    volumes:
-      - ./:/home/node/app
-    command: node /home/node/app/dist/test.js
-
-  coingecko-writer:
-    image: node:alpine
-    volumes:
-      - ./:/home/node/app
-    environment:
-      - DISABLE_REST_API=true
-    command: node /home/node/app/dist/test.js
-
-  lb:
-    image: dockercloud/haproxy
-    links:
-      - coingecko-reader
-    ports:
-      - '80:80'
-    volumes:
-      - /var/run/docker.sock:/var/run/docker.sock