@chainlink/external-adapter-framework 0.0.3 → 0.0.4

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

@@ -7,6 +7,7 @@ runs:
       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/{publish2.yaml → publish.yaml}

@@ -1,17 +1,18 @@
 # 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 # TODO REMOVE BEFORE PR
+  workflow_dispatch:
+  push:
+    #branches:
+      #- master
+      #- main
 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: yarn build
-      - run: yarn config get registry
-      - run: ls -la
       - 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 }}
+    env:
+      NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chainlink/external-adapter-framework",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "main": "dist/index.js",
   "license": "MIT",
   "dependencies": {

package/dist/adapter.js

@@ -1,60 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.initializeAdapter = exports.initializeDependencies = void 0;
-const factory_1 = require("./cache/factory");
-const rate_limiting_1 = require("./rate-limiting");
-const util_1 = require("./util");
-const logger = (0, util_1.makeLogger)('Adapter');
-/**
- * This function will process dependencies for an adapter, such as caches or rate limiters,
- * in order to inject them into transports and other relevant places later in the lifecycle.
- *
- * @param config - the configuration for this adapter
- * @param inputDependencies - a partial obj of initialized dependencies to override the created ones
- * @param rateLimitingConfig - details from the adapter regarding rate limiting
- * @returns a set of AdapterDependencies all initialized
- */
-const initializeDependencies = (config, inputDependencies, rateLimitingConfig) => {
-    const dependencies = inputDependencies || {};
-    if (!dependencies.cache) {
-        dependencies.cache = factory_1.CacheFactory.buildCache(config);
-    }
-    if (!dependencies.rateLimiter) {
-        const rateLimiter = rate_limiting_1.RateLimiterFactory.buildRateLimiter(rateLimitingConfig?.tiers, config['RATE_LIMIT_API_TIER'], rateLimitingConfig?.strategy);
-        dependencies.rateLimiter = rateLimiter;
-    }
-    return dependencies;
-};
-exports.initializeDependencies = initializeDependencies;
-/**
- * Initializes all of the [[Transport]]s in the adapter, passing along any [[AdapterDependencies]] and [[AdapterConfig]].
- * Additionally, it builds a map out of all the endpoint names and aliases (checking for duplicates).
- *
- * @param adapter - an instance of an Adapter
- * @param dependencies - dependencies that the adapter will need at initialization
- * @param config - configuration variables already processed and validated
- * @returns - the adapter with all transports initialized and aliases map built
- */
-const initializeAdapter = async (adapter, config, dependencies) => {
-    const initializedDependencies = (0, exports.initializeDependencies)(config, dependencies, adapter.rateLimiting);
-    const endpointsMap = {};
-    for (const endpoint of adapter.endpoints) {
-        // Add aliases to map to use in validation
-        const aliases = [endpoint.name, ...(endpoint.aliases || [])];
-        for (const alias of aliases) {
-            if (endpointsMap[alias]) {
-                throw new Error(`Duplicate endpoint / alias: "${alias}"`);
-            }
-            endpointsMap[alias] = endpoint;
-        }
-        logger.debug(`Initializing transport for endpoint "${endpoint.name}"...`);
-        await endpoint.transport.initialize(initializedDependencies);
-    }
-    return {
-        ...adapter,
-        endpointsMap,
-        dependencies: initializedDependencies,
-        config,
-    };
-};
-exports.initializeAdapter = initializeAdapter;

package/dist/background-executor.js

@@ -1,45 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.callBackgroundExecutes = void 0;
-const util_1 = require("./util");
-const logger = (0, util_1.makeLogger)('BackgroundExecutor');
-/**
- * Very simple background loop that will call the [[Transport.backgroundExecute]] functions in all Transports.
- * It gets the time in ms to wait as the return value from those functions, and sleeps until next execution.
- *
- * @param adapter - an initialized External Adapter
- * @param server - the http server to attach an on close listener to
- */
-async function callBackgroundExecutes(adapter, server) {
-    // Set up variable to check later on to see if we need to stop this background "thread"
-    // If no server is provided, the listener won't be set and serverClosed will always be false
-    let serverClosed = false;
-    server?.on('close', () => {
-        serverClosed = true;
-    });
-    for (const endpoint of adapter.endpoints) {
-        const backgroundExecute = endpoint.transport.backgroundExecute?.bind(endpoint.transport);
-        if (!backgroundExecute) {
-            logger.debug(`Endpoint "${endpoint.name}" has no background execute, skipping...`);
-            continue;
-        }
-        const context = {
-            adapterEndpoint: endpoint,
-            adapterConfig: adapter.config,
-        };
-        const handler = async () => {
-            if (serverClosed) {
-                logger.info('Server closed, stopping recursive backgroundExecute handler chain');
-                return;
-            }
-            logger.debug(`Calling background execute for endpoint "${endpoint.name}"`);
-            const timeToWait = await backgroundExecute(context);
-            logger.debug(`Finished background execute for endpoint "${endpoint.name}", sleeping for ${timeToWait}ms`);
-            await (0, util_1.sleep)(timeToWait);
-            handler();
-        };
-        // Start recursive async calls
-        handler();
-    }
-}
-exports.callBackgroundExecutes = callBackgroundExecutes;

package/dist/cache/factory.js

@@ -1,57 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CacheFactory = void 0;
-const ioredis_1 = __importDefault(require("ioredis"));
-const util_1 = require("../util");
-const local_1 = require("./local");
-const cacheMetrics = __importStar(require("./metrics"));
-const redis_1 = require("./redis");
-const logger = (0, util_1.makeLogger)('CacheFactory');
-class CacheFactory {
-    static buildCache(config) {
-        logger.info(`Using "${config.CACHE_TYPE}" cache.`);
-        if (config.CACHE_TYPE === 'local') {
-            return new local_1.LocalCache();
-        }
-        else if (config.CACHE_TYPE === 'redis') {
-            const redis = new ioredis_1.default({
-                enableAutoPipelining: true,
-                host: config.CACHE_REDIS_HOST,
-                port: config.CACHE_REDIS_PORT,
-            });
-            redis.on('connect', () => {
-                cacheMetrics.redisConnectionsOpen.inc();
-            });
-            // TODO: Maybe track active redis connections instead of just total count of connections created
-            // Use a Gauge and track with a combo of connect/end events listeners
-            return new redis_1.RedisCache(redis);
-        }
-    }
-}
-exports.CacheFactory = CacheFactory;

package/dist/cache/index.js

@@ -1,163 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildCacheMiddleware = exports.pollResponseFromCache = exports.calculateKey = exports.calculateFeedId = exports.calculateCacheKey = void 0;
-const util_1 = require("../util");
-const cacheMetrics = __importStar(require("./metrics"));
-__exportStar(require("./local"), exports);
-__exportStar(require("./redis"), exports);
-const logger = (0, util_1.makeLogger)('Cache');
-// Uses calculateKey to generate a unique key from the endpoint name, data, and input parameters
-const calculateCacheKey = ({ adapterEndpoint, adapterConfig, }, data) => {
-    const paramNames = Object.keys(adapterEndpoint.inputParameters);
-    if (paramNames.length === 0) {
-        logger.trace(`Using default cache key ${adapterConfig.DEFAULT_CACHE_KEY}`);
-        return adapterConfig.DEFAULT_CACHE_KEY;
-    }
-    return `${adapterEndpoint.name}-${(0, exports.calculateKey)(data, paramNames)}`;
-};
-exports.calculateCacheKey = calculateCacheKey;
-const calculateFeedId = (adapterEndpoint, data) => {
-    const paramNames = Object.keys(adapterEndpoint.inputParameters);
-    if (paramNames.length === 0) {
-        logger.trace(`Cannot generate Feed ID without input parameters`);
-        return 'N/A';
-    }
-    return (0, exports.calculateKey)(data, paramNames);
-};
-exports.calculateFeedId = calculateFeedId;
-/**
- * Calculates a unique key from the provided data.
- *
- * @param data - the request data/body, i.e. the adapter input params
- * @param paramNames - the keys from adapter endpoint input parameters
- * @returns the calculated unique key
- *
- * @example
- * ```
- * calculateKey({ base: 'ETH', quote: 'BTC' }, ['base','quote'])
- * // equals `|base:eth|quote:btc`
- * ```
- */
-const calculateKey = (data, paramNames) => {
-    if (data && typeof data !== 'object') {
-        throw new Error('Data to calculate cache key should be an object');
-    }
-    const params = data;
-    let cacheKey = ''; // TODO: Maybe there's a faster String Builder
-    for (const paramName of paramNames) {
-        // Ignore overrides param when generating cache keys
-        // TODO: expand support for ignoring `includes` and `tokenOverrides` params when generating keys
-        if (paramName === 'overrides') {
-            continue;
-        }
-        const param = params[paramName];
-        if (param === undefined) {
-            continue;
-        }
-        cacheKey += `|${paramName}:`;
-        switch (typeof param) {
-            case 'string':
-                cacheKey += param.toLowerCase();
-                break;
-            case 'number':
-            case 'boolean':
-                cacheKey += param.toString();
-                break;
-            case 'object':
-                // TODO: Implement object sorting for deterministic cache key generation
-                cacheKey += JSON.stringify(param);
-        }
-    }
-    // TODO: Check max size, potential issue
-    logger.trace(`Generated cache key for request: "${cacheKey}"`);
-    return cacheKey;
-};
-exports.calculateKey = calculateKey;
-// Calculate the amount of time the non-expired entry has been in the cache
-const calculateStaleness = (expirationTimestamp, ttl) => {
-    if (expirationTimestamp) {
-        const createTimestamp = expirationTimestamp - ttl;
-        return (Date.now() - createTimestamp) / 1000;
-    }
-    else {
-        // If expirationTimestamp is not available, staleness cannot be calculated
-        // Defaults to ttl for metrics purposes
-        return ttl;
-    }
-};
-/**
- * Polls the provided Cache for an AdapterResponse set in the provided key. If the maximum
- * amount of retries is exceeded, it returns undefined instead.
- *
- * @param cache - a Cache instance
- * @param key - the key generated from an AdapterRequest that corresponds to the desired AdapterResponse
- * @param retry - current retry, only for internal use
- * @returns the AdapterResponse if found, else undefined
- */
-const pollResponseFromCache = async (cache, key, options, retry = 0) => {
-    if (retry > options.maxRetries) {
-        // Ideally this shouldn't happen often (p99 of reqs should be found in the cache)
-        logger.info('Exceeded max cache polling retries');
-        return undefined;
-    }
-    logger.trace('Getting response from cache...');
-    const response = await cache.get(key);
-    if (response) {
-        logger.trace('Got response from cache');
-        return response;
-    }
-    if (options.maxRetries === 0) {
-        logger.debug(`Response not found, retries disabled`);
-        return undefined;
-    }
-    logger.debug(`Response not found, sleeping ${options.sleep} milliseconds...`);
-    await (0, util_1.sleep)(options.sleep);
-    return (0, exports.pollResponseFromCache)(cache, key, options, retry + 1);
-};
-exports.pollResponseFromCache = pollResponseFromCache;
-/**
- * Given a Cache instance in the adapter dependencies, builds a middleware function that will perform
- * a get from said Cache and return that if found; otherwise it'll continue the middleware chain.
- *
- * @param adapter - an initialized adapter
- * @returns the cache middleware function
- */
-const buildCacheMiddleware = (adapter) => async (req, res) => {
-    const response = await adapter.dependencies.cache.get(req.requestContext.cacheKey);
-    if (response) {
-        logger.debug('Found response from cache, sending that');
-        const label = cacheMetrics.cacheMetricsLabel(req.requestContext.cacheKey, req.requestContext.metricsMeta?.feedId || 'N/A', adapter.config.CACHE_TYPE);
-        // Record cache staleness and cache get count and value
-        const staleness = calculateStaleness(response.maxAge, adapter.config.CACHE_MAX_AGE);
-        cacheMetrics.cacheGet(label, response.result, staleness);
-        return res.send(response);
-    }
-    logger.debug('Did not find response in cache, moving to next middleware');
-};
-exports.buildCacheMiddleware = buildCacheMiddleware;

package/dist/cache/local.js

@@ -1,83 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LocalCache = void 0;
-const util_1 = require("../util");
-const cacheMetrics = __importStar(require("./metrics"));
-const logger = (0, util_1.makeLogger)('LocalCache');
-/**
- * Local implementation of a Cache. It uses a simple js Object, storing entries with both
- * a value and an expiration timestamp. Expired entries are deleted on reads (i.e. no background gc/upkeep).
- *
- * @typeParam T - the type for the entries' values
- */
-class LocalCache {
-    constructor() {
-        this.store = {};
-    }
-    async get(key) {
-        logger.trace(`Getting key ${key}`);
-        const entry = this.store[key];
-        if (!entry) {
-            logger.debug(`No entry in local cache for key "${key}", returning undefined`);
-            return undefined;
-        }
-        const expired = entry.expirationTimestamp <= Date.now();
-        if (expired) {
-            logger.debug('Entry in local cache expired, deleting and returning undefined');
-            this.delete(key);
-            return undefined;
-        }
-        else {
-            logger.debug('Found valid entry in local cache, returning value');
-            return entry.value;
-        }
-    }
-    async delete(key) {
-        logger.trace(`Deleting key ${key}`);
-        delete this.store[key]; // Deletes are slower than ignoring or setting null, fyi
-    }
-    async set(key, value, ttl) {
-        logger.trace(`Setting key ${key} with ttl ${ttl}`);
-        this.store[key] = {
-            value,
-            expirationTimestamp: Date.now() + ttl,
-        };
-        // Only record metrics if feed Id is present, otherwise assuming value is not adapter response to record
-        const feedId = value.metricsMeta?.feedId;
-        if (feedId) {
-            // Record cache set count, max age, and staleness (set to 0 for cache set)
-            const label = cacheMetrics.cacheMetricsLabel(key, feedId, cacheMetrics.CacheTypes.Local);
-            cacheMetrics.cacheSet(label, ttl);
-        }
-    }
-    async setMany(entries, ttl) {
-        logger.trace(`Setting a bunch of keys with ttl ${ttl}`);
-        for (const { key, value } of entries) {
-            this.set(key, value, ttl);
-        }
-    }
-}
-exports.LocalCache = LocalCache;

package/dist/cache/metrics.js

@@ -1,114 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.redisCommandsSentCount = exports.redisRetriesCount = exports.redisConnectionsOpen = exports.CMD_SENT_STATUS = exports.CacheTypes = exports.cacheMetricsLabel = exports.cacheSet = exports.cacheGet = void 0;
-const client = __importStar(require("prom-client"));
-const cacheGet = (label, value, staleness) => {
-    if (typeof value === 'number' || typeof value === 'string') {
-        const parsedValue = Number(value);
-        if (!Number.isNaN(parsedValue) && Number.isFinite(parsedValue)) {
-            cacheDataGetValues.labels(label).set(parsedValue);
-        }
-    }
-    cacheDataGetCount.labels(label).inc();
-    cacheDataStalenessSeconds.labels(label).set(staleness);
-};
-exports.cacheGet = cacheGet;
-const cacheSet = (label, maxAge) => {
-    cacheDataSetCount.labels(label).inc();
-    cacheDataMaxAge.labels(label).set(maxAge);
-    cacheDataStalenessSeconds.labels(label).set(0);
-};
-exports.cacheSet = cacheSet;
-const cacheMetricsLabel = (cacheKey, feedId, cacheType) => ({
-    participant_id: cacheKey,
-    feed_id: feedId,
-    cache_type: cacheType,
-});
-exports.cacheMetricsLabel = cacheMetricsLabel;
-var CacheTypes;
-(function (CacheTypes) {
-    CacheTypes["Redis"] = "redis";
-    CacheTypes["Local"] = "local";
-})(CacheTypes = exports.CacheTypes || (exports.CacheTypes = {}));
-var CMD_SENT_STATUS;
-(function (CMD_SENT_STATUS) {
-    CMD_SENT_STATUS["TIMEOUT"] = "TIMEOUT";
-    CMD_SENT_STATUS["FAIL"] = "FAIL";
-    CMD_SENT_STATUS["SUCCESS"] = "SUCCESS";
-})(CMD_SENT_STATUS = exports.CMD_SENT_STATUS || (exports.CMD_SENT_STATUS = {}));
-const baseLabels = [
-    'feed_id',
-    'participant_id',
-    'cache_type',
-    'is_from_ws',
-    'experimental',
-];
-// Skipping this metrics for v3
-// const cache_execution_duration_seconds = new client.Histogram({
-//   name: 'cache_execution_duration_seconds',
-//   help: 'A histogram bucket of the distribution of cache execution durations',
-//   labelNames: [...baseLabels, 'cache_hit'] as const,
-//   buckets: [0.01, 0.1, 1, 10],
-// })
-const cacheDataGetCount = new client.Counter({
-    name: 'cache_data_get_count',
-    help: 'A counter that increments every time a value is fetched from the cache',
-    labelNames: baseLabels,
-});
-const cacheDataGetValues = new client.Gauge({
-    name: 'cache_data_get_values',
-    help: 'A gauge keeping track of values being fetched from cache',
-    labelNames: baseLabels,
-});
-const cacheDataMaxAge = new client.Gauge({
-    name: 'cache_data_max_age',
-    help: 'A gauge tracking the max age of stored values in the cache',
-    labelNames: baseLabels,
-});
-const cacheDataSetCount = new client.Counter({
-    name: 'cache_data_set_count',
-    help: 'A counter that increments every time a value is set to the cache',
-    labelNames: [...baseLabels, 'status_code'],
-});
-const cacheDataStalenessSeconds = new client.Gauge({
-    name: 'cache_data_staleness_seconds',
-    help: 'Observes the staleness of the data returned',
-    labelNames: baseLabels,
-});
-// Redis Metrics
-exports.redisConnectionsOpen = new client.Counter({
-    name: 'redis_connections_open',
-    help: 'The number of redis connections that are open',
-});
-exports.redisRetriesCount = new client.Counter({
-    name: 'redis_retries_count',
-    help: 'The number of retries that have been made to establish a redis connection',
-});
-exports.redisCommandsSentCount = new client.Counter({
-    name: 'redis_commands_sent_count',
-    help: 'The number of redis commands sent',
-    labelNames: ['status', 'function_name'],
-});

package/dist/cache/redis.js

@@ -1,100 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedisCache = void 0;
-const util_1 = require("../util");
-const cacheMetrics = __importStar(require("./metrics"));
-const logger = (0, util_1.makeLogger)('RedisCache');
-/**
- * Redis implementation of a Cache. It uses a simple js Object, storing entries with both
- * a value and an expiration timestamp. Expired entries are deleted on reads (i.e. no background gc/upkeep).
- *
- * @typeParam T - the type for the entries' values
- */
-// TODO: Add error handling for redis command failures
-class RedisCache {
-    constructor(client) {
-        this.client = client;
-    }
-    async get(key) {
-        logger.trace(`Getting key ${key}`);
-        const value = await this.client.get(key);
-        // Record get command sent to Redis
-        cacheMetrics.redisCommandsSentCount
-            .labels({ status: cacheMetrics.CMD_SENT_STATUS.SUCCESS, function_name: 'get' })
-            .inc();
-        if (!value) {
-            logger.debug(`No entry in redis cache for key "${key}", returning undefined`);
-            return undefined;
-        }
-        return JSON.parse(value); // TODO: Check for invalid parsing
-    }
-    async delete(key) {
-        logger.trace(`Deleting key ${key}`);
-        await this.client.del(key);
-        // Record delete command sent to Redis
-        cacheMetrics.redisCommandsSentCount
-            .labels({ status: cacheMetrics.CMD_SENT_STATUS.SUCCESS, function_name: 'delete' })
-            .inc();
-    }
-    async set(key, value, ttl) {
-        logger.trace(`Setting key ${key}`);
-        // TODO: Check for invalid stringify
-        await this.client.set(key, JSON.stringify(value), 'PX', ttl);
-        // Only record metrics if feed Id is present, otherwise assuming value is not adapter response to record
-        const feedId = value.metricsMeta?.feedId;
-        if (feedId) {
-            // Record cache set count, max age, and staleness (set to 0 for cache set)
-            const label = cacheMetrics.cacheMetricsLabel(key, feedId, cacheMetrics.CacheTypes.Redis);
-            cacheMetrics.cacheSet(label, ttl);
-        }
-        // Record set command sent to Redis
-        cacheMetrics.redisCommandsSentCount
-            .labels({ status: cacheMetrics.CMD_SENT_STATUS.SUCCESS, function_name: 'set' })
-            .inc();
-    }
-    async setMany(entries, ttl) {
-        logger.trace(`Setting a bunch of keys`);
-        // Unfortunately, there's no ttl for mset
-        let chain = this.client.multi();
-        for (const entry of entries) {
-            chain = chain.set(entry.key, JSON.stringify(entry.value), 'PX', ttl);
-            // TODO: Move to after error handling once implemented to avoid recording cache sets that failed
-            // Only record metrics if feed Id is present, otherwise assuming value is not adapter response to record
-            const feedId = entry.value.metricsMeta?.feedId;
-            if (feedId) {
-                // Record cache set count, max age, and staleness (set to 0 for cache set)
-                const label = cacheMetrics.cacheMetricsLabel(entry.key, feedId, cacheMetrics.CacheTypes.Redis);
-                cacheMetrics.cacheSet(label, ttl);
-            }
-        }
-        await chain.exec();
-        // Record setMany command sent to Redis
-        cacheMetrics.redisCommandsSentCount
-            .labels({ status: cacheMetrics.CMD_SENT_STATUS.SUCCESS, function_name: 'exec' })
-            .inc();
-    }
-}
-exports.RedisCache = RedisCache;