@chainlink/external-adapter-framework 0.0.12 → 0.0.15

package/dist/src/adapter.d.ts

@@ -1,135 +0,0 @@
-import { Cache } from './cache';
-import { AdapterConfig, BaseAdapterConfig, CustomSettingsType, SettingsMap } from './config';
-import { AdapterRateLimitTier, BackgroundExecuteRateLimiter, RequestRateLimiter } from './rate-limiting';
-import { Transport } from './transports';
-import { SubscriptionSetFactory } from './util';
-import { InputParameters } from './validation/input-params';
-/**
- * Dependencies that will be injected into the Adapter on startup
- */
-export interface AdapterDependencies {
-    cache: Cache;
-    requestRateLimiter: RequestRateLimiter;
-    backgroundExecuteRateLimiter: BackgroundExecuteRateLimiter;
-    subscriptionSetFactory: SubscriptionSetFactory;
-}
-/**
- * Context that will be used on background executions of a Transport.
- * For example, the endpointName used to log statements or generate Cache keys.
- */
-export interface AdapterContext<CustomSettings extends CustomSettingsType<CustomSettings> = SettingsMap> {
-    adapterEndpoint: AdapterEndpoint<unknown, unknown, CustomSettings>;
-    adapterConfig: AdapterConfig<CustomSettings>;
-}
-/**
- * Structure to describe rate limits specs for the Adapter
- */
-interface AdapterRateLimitingConfig {
-    /** Adapter rate limits, gotten from the specific tier requested */
-    tiers: Record<string, AdapterRateLimitTier>;
-}
-/**
- * Main structure of an External Adapter
- */
-export interface AdapterParams<CustomSettings extends SettingsMap> {
-    /** Name of the adapter */
-    name: string;
-    /** If present, the string that will be used for requests with no specified endpoint */
-    defaultEndpoint?: string;
-    /**
-     * List of [[AdapterEndpoint]]s in the adapter. This is purposefully typed any; it's the correct type in this case.
-     *
-     * When you try to create an adapter and you provide an endpoint, if these generics were set to "unknown" instead
-     * what would happen is that Typescript would check if the types match, and would fail to assign unknown to the
-     * specific Params or Result in the transport itself.
-     * We also can't use generics, because if we had more than one transport with different requests (very likely)
-     * then those new types wouldn't match with each other.
-     */
-    endpoints: AdapterEndpoint<any, any, CustomSettings>[];
-    /** Map of overrides to the default config values for an Adapter */
-    envDefaultOverrides?: Partial<BaseAdapterConfig>;
-    /** List of custom env vars for this particular adapter (e.g. RPC_URL) */
-    customSettings?: SettingsMap;
-    /** Configuration relevant to outbound (EA --\> DP) communication rate limiting */
-    rateLimiting?: AdapterRateLimitingConfig;
-    /** Overrides for converting the 'base' parameter that are hardcoded into the adapter. */
-    overrides?: Record<string, string>;
-}
-/**
- * Structure to describe rate limits specs for a specific adapter endpoint
- */
-export interface EndpointRateLimitingConfig {
-    /**
-     * How much of the total limit for the adapter will be assigned to this specific endpoint.
-     * Should be a non-zero positive number up to 100.
-     * Endpoints in the same adapter without a specific allocation will divide the remaining limits equally.
-     */
-    allocationPercentage: number;
-}
-/**
- * Structure to describe a specific endpoint in an [[Adapter]]
- */
-export interface AdapterEndpointParams<Params, Result, CustomSettings extends SettingsMap> {
-    /** Name that will be used to match input params to this endpoint (case insensitive) */
-    name: string;
-    /** List of alternative endpoint names that will resolve to this same transport (case insensitive) */
-    aliases?: string[];
-    /** Transport that will be used to handle data processing and communication for this endpoint */
-    transport: Transport<Params, Result, CustomSettings>;
-    /** Specification of what the body of a request hitting this endpoint should look like (used for validation) */
-    inputParameters: InputParameters;
-    /** Specific details related to the rate limiting for this endpoint in particular */
-    rateLimiting?: EndpointRateLimitingConfig;
-}
-export declare class AdapterEndpoint<Params, Result, CustomSettings extends SettingsMap> implements AdapterEndpointParams<Params, Result, CustomSettings> {
-    name: string;
-    aliases?: string[] | undefined;
-    transport: Transport<Params, Result, CustomSettings>;
-    inputParameters: InputParameters;
-    rateLimiting?: EndpointRateLimitingConfig | undefined;
-    constructor(params: AdapterEndpointParams<Params, Result, CustomSettings>);
-}
-export declare class Adapter<CustomSettings extends SettingsMap = SettingsMap> implements AdapterParams<CustomSettings> {
-    name: string;
-    defaultEndpoint?: string | undefined;
-    endpoints: AdapterEndpoint<unknown, unknown, CustomSettings>[];
-    envDefaultOverrides?: Partial<BaseAdapterConfig> | undefined;
-    customSettings?: SettingsMap | undefined;
-    rateLimiting?: AdapterRateLimitingConfig | undefined;
-    overrides?: Record<string, string> | undefined;
-    initialized: boolean;
-    /** Object containing alias translations for all endpoints */
-    endpointsMap: Record<string, AdapterEndpoint<unknown, unknown, CustomSettings>>;
-    /** Initialized dependencies that the adapter will use */
-    dependencies: AdapterDependencies;
-    /** Configuration params for various adapter properties */
-    config: AdapterConfig;
-    constructor(params: AdapterParams<CustomSettings>);
-    /**
-     * 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).
-     */
-    initialize(dependencies?: Partial<AdapterDependencies>): Promise<void>;
-    /**
-     * Takes an adapter and normalizes all endpoint names and aliases, as well as the default endpoint.
-     * i.e. makes them lowercase for now
-     * @param adapter - an instance of an Adapter
-     */
-    private normalizeEndpointNames;
-    /**
-     * This function will take an adapter structure and go through each endpoint, calculating
-     * each one's allocation of the total rate limits that are set for the adapter as a whole.
-     *
-     * @param adapter - the adapter to initialize rate limiting for
-     */
-    private calculateRateLimitAllocations;
-    /**
-     * 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 inputDependencies - a partial obj of initialized dependencies to override the created ones
-     * @returns a set of AdapterDependencies all initialized
-     */
-    initializeDependencies(inputDependencies?: Partial<AdapterDependencies>): AdapterDependencies;
-}
-export {};

package/dist/src/adapter.js

@@ -1,145 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Adapter = exports.AdapterEndpoint = void 0;
-const cache_1 = require("./cache");
-const config_1 = require("./config");
-const rate_limiting_1 = require("./rate-limiting");
-const util_1 = require("./util");
-const logger = (0, util_1.makeLogger)('Adapter');
-class AdapterEndpoint {
-    constructor(params) {
-        this.name = params.name;
-        this.aliases = params.aliases;
-        this.transport = params.transport;
-        this.inputParameters = params.inputParameters;
-        this.rateLimiting = params.rateLimiting;
-    }
-}
-exports.AdapterEndpoint = AdapterEndpoint;
-// /**
-//  * Structure to describe an adapter that has been initialized
-//  */
-// export interface InitializedAdapter<Params, Result, CustomSettings extends SettingsMap>
-//   extends AdapterParams<Params, Result, CustomSettings> {
-//   /** Object containing alias translations for all endpoints */
-//   endpointsMap: Record<string, AdapterEndpoint<Params, Result, CustomSettings>>
-//   /** Initialized dependencies that the adapter will use */
-//   dependencies: AdapterDependencies
-//   /** Configuration params for various adapter properties */
-//   config: AdapterConfig
-// }
-class Adapter {
-    constructor(params) {
-        // After initialization
-        this.initialized = false;
-        /** Object containing alias translations for all endpoints */
-        this.endpointsMap = {};
-        // Copy over params
-        this.name = params.name;
-        this.defaultEndpoint = params.defaultEndpoint?.toLowerCase();
-        this.endpoints = params.endpoints;
-        this.envDefaultOverrides = params.envDefaultOverrides;
-        this.customSettings = params.customSettings;
-        this.rateLimiting = params.rateLimiting;
-        this.overrides = params.overrides;
-        this.config = (0, config_1.buildAdapterConfig)({
-            overrides: this.envDefaultOverrides,
-            customSettings: this.customSettings,
-        });
-        this.normalizeEndpointNames();
-        this.calculateRateLimitAllocations();
-    }
-    /**
-     * 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).
-     */
-    async initialize(dependencies) {
-        if (this.initialized) {
-            throw new Error('This adapter has already been initialized!');
-        }
-        this.dependencies = this.initializeDependencies(dependencies);
-        for (const endpoint of this.endpoints) {
-            // Add aliases to map to use in validation
-            const aliases = [endpoint.name, ...(endpoint.aliases || [])];
-            for (const alias of aliases) {
-                if (this.endpointsMap[alias]) {
-                    throw new Error(`Duplicate endpoint / alias: "${alias}"`);
-                }
-                this.endpointsMap[alias] = endpoint;
-            }
-            logger.debug(`Initializing transport for endpoint "${endpoint.name}"...`);
-            await endpoint.transport.initialize(this.dependencies);
-        }
-        logger.debug('Adapter initialization complete.');
-        this.initialized = true;
-    }
-    /**
-     * Takes an adapter and normalizes all endpoint names and aliases, as well as the default endpoint.
-     * i.e. makes them lowercase for now
-     * @param adapter - an instance of an Adapter
-     */
-    normalizeEndpointNames() {
-        for (const endpoint of this.endpoints) {
-            endpoint.name = endpoint.name.toLowerCase();
-            endpoint.aliases = endpoint.aliases?.map((a) => a.toLowerCase());
-        }
-    }
-    /**
-     * This function will take an adapter structure and go through each endpoint, calculating
-     * each one's allocation of the total rate limits that are set for the adapter as a whole.
-     *
-     * @param adapter - the adapter to initialize rate limiting for
-     */
-    calculateRateLimitAllocations() {
-        const numberOfEndpoints = this.endpoints.length;
-        const endpointsWithExplicitAllocations = this.endpoints.filter((e) => e.rateLimiting);
-        const totalExplicitAllocation = endpointsWithExplicitAllocations
-            .map((e) => e.rateLimiting?.allocationPercentage || 0)
-            .reduce((sum, next) => sum + next, 0);
-        if (totalExplicitAllocation > 100) {
-            throw new Error('The total allocation set for all endpoints summed cannot exceed 100%');
-        }
-        if (totalExplicitAllocation === 100 &&
-            numberOfEndpoints - endpointsWithExplicitAllocations.length > 0) {
-            throw new Error('The explicit allocation is at 100% but there are endpoints with implicit allocation');
-        }
-        const implicitAllocation = 100 - totalExplicitAllocation;
-        logger.debug('Adapter rate limit allocations:');
-        for (const endpoint of this.endpoints) {
-            if (!endpoint.rateLimiting) {
-                endpoint.rateLimiting = {
-                    allocationPercentage: implicitAllocation / (numberOfEndpoints - endpointsWithExplicitAllocations.length),
-                };
-            }
-            logger.debug(`Endpoint [${endpoint.name}] - ${endpoint.rateLimiting?.allocationPercentage}%`);
-        }
-    }
-    /**
-     * 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 inputDependencies - a partial obj of initialized dependencies to override the created ones
-     * @returns a set of AdapterDependencies all initialized
-     */
-    initializeDependencies(inputDependencies) {
-        const dependencies = inputDependencies || {};
-        if (!dependencies.cache) {
-            dependencies.cache = cache_1.CacheFactory.buildCache(this.config);
-        }
-        // In the future we might want something more complex, but for now it's better to simplify
-        // and just use the same rate limiting for everything. Once we have a more complex use case we
-        // can think of ways to make this more configurable.
-        const rateLimitingTier = (0, rate_limiting_1.getRateLimitingTier)(this.rateLimiting?.tiers, this.config.RATE_LIMIT_API_TIER);
-        if (!dependencies.requestRateLimiter) {
-            dependencies.requestRateLimiter = new rate_limiting_1.SimpleCountingRateLimiter().initialize(this.endpoints, rateLimitingTier);
-        }
-        if (!dependencies.backgroundExecuteRateLimiter) {
-            dependencies.backgroundExecuteRateLimiter = new rate_limiting_1.FixedFrequencyRateLimiter().initialize(this.endpoints, rateLimitingTier);
-        }
-        if (!dependencies.subscriptionSetFactory) {
-            dependencies.subscriptionSetFactory = new util_1.SubscriptionSetFactory(this.config);
-        }
-        return dependencies;
-    }
-}
-exports.Adapter = Adapter;

package/dist/src/background-executor.d.ts

@@ -1,11 +0,0 @@
-/// <reference types="node" />
-import { Server } from 'http';
-import { Adapter } from './adapter';
-/**
- * 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
- */
-export declare function callBackgroundExecutes(adapter: Adapter, server?: Server): Promise<void>;

package/dist/src/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/src/cache/factory.d.ts

@@ -1,6 +0,0 @@
-import { AdapterConfig } from '../config';
-import { LocalCache } from './local';
-import { RedisCache } from './redis';
-export declare class CacheFactory {
-    static buildCache(config: AdapterConfig): LocalCache<unknown> | RedisCache<unknown> | undefined;
-}

package/dist/src/cache/factory.js

@@ -1,55 +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();
-            });
-            return new redis_1.RedisCache(redis);
-        }
-    }
-}
-exports.CacheFactory = CacheFactory;

package/dist/src/cache/index.d.ts

@@ -1,94 +0,0 @@
-import { AdapterEndpoint } from '../adapter';
-import { AdapterConfig, SettingsMap } from '../config';
-import { AdapterMiddlewareBuilder, AdapterResponse, sleep } from '../util';
-export * from './local';
-export * from './redis';
-export * from './factory';
-/**
- * An object describing an entry in the cache.
- * @typeParam T - the type of the entry's value
- */
-export interface CacheEntry<T> {
-    key: string;
-    value: T;
-}
-/**
- * Generic interface for a local or remote Cache.
- * @typeParam T - the type of the cache entries' values
- */
-export interface Cache<T = unknown> {
-    /**
-     * Gets an item from the Cache.
-     *
-     * @param key - the key of the desired entry for which to fetch its value
-     * @returns a Promise of the entry's value, or undefined if not found / expired.
-     */
-    get: (key: string) => Promise<T | undefined>;
-    /**
-     * Sets an item in the Cache.
-     *
-     * @param key - the key of the new entry
-     * @param value - the value of the new entry
-     * @param ttl - the time in milliseconds until the entry expires
-     * @returns an empty Promise that resolves when the entry has been set
-     */
-    set: (key: string, value: T, ttl: number) => Promise<void>;
-    /**
-     * Sets a list of items in the Cache.
-     *
-     * @param entries - a list of cache entries
-     * @param ttl - the time in milliseconds until the entries expire
-     * @returns an empty Promise that resolves when all entries have been set
-     */
-    setMany: (entries: CacheEntry<T>[], ttl: number) => Promise<void>;
-    /**
-     * Deletes the specified item from the Cache
-     *
-     * @param key - the key of the entry to be deleted
-     * @returns an empty Promise that resolves when the entry has been deleted
-     */
-    delete: (key: string) => Promise<void>;
-}
-export declare const calculateCacheKey: <Params, Result, CustomSettings extends SettingsMap>({ adapterEndpoint, adapterConfig, }: {
-    adapterEndpoint: AdapterEndpoint<Params, Result, CustomSettings>;
-    adapterConfig: AdapterConfig<CustomSettings>;
-}, data: unknown) => string;
-export declare const calculateFeedId: <Params, Result, CustomSettings extends SettingsMap>({ adapterEndpoint, adapterConfig, }: {
-    adapterEndpoint: AdapterEndpoint<Params, Result, CustomSettings>;
-    adapterConfig: AdapterConfig<CustomSettings>;
-}, data: unknown) => string;
-/**
- * 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`
- * ```
- */
-export declare const calculateKey: <CustomSettings extends SettingsMap>(data: unknown, paramNames: string[], adapterConfig: AdapterConfig<CustomSettings>) => string;
-/**
- * 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
- */
-export declare const pollResponseFromCache: (cache: Cache<AdapterResponse>, key: string, options: {
-    maxRetries: number;
-    sleep: number;
-}, retry?: number) => Promise<AdapterResponse | undefined>;
-/**
- * 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
- */
-export declare const buildCacheMiddleware: AdapterMiddlewareBuilder;

package/dist/src/cache/index.js

@@ -1,173 +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);
-__exportStar(require("./factory"), 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, adapterConfig)}`;
-};
-exports.calculateCacheKey = calculateCacheKey;
-const calculateFeedId = ({ adapterEndpoint, adapterConfig, }, 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, adapterConfig);
-};
-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, adapterConfig) => {
-    if (data && typeof data !== 'object') {
-        throw new Error('Data to calculate cache key should be an object');
-    }
-    const params = data;
-    let cacheKey = '';
-    for (const paramName of paramNames) {
-        // Ignore overrides param when generating cache 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':
-                // Force cache keys to only use performant properties of the input params.
-                // If the object were to be used, we'd have to sort its properties.
-                logger.debug(`Property "${paramName}" in request parameters is of type object, and won't be used in the cacheKey`);
-        }
-    }
-    if (cacheKey.length > adapterConfig.MAX_COMMON_KEY_SIZE) {
-        logger.warn(`Generated cache key for adapter request is bigger than the MAX_COMMON_KEY_SIZE and will be truncated`);
-        cacheKey = cacheKey.slice(0, adapterConfig.MAX_COMMON_KEY_SIZE);
-    }
-    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');
-        if (adapter.config.METRICS_ENABLED && adapter.config.EXPERIMENTAL_METRICS_ENABLED) {
-            const label = cacheMetrics.cacheMetricsLabel(req.requestContext.cacheKey, req.requestContext.meta?.metrics?.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);
-            req.requestContext.meta = {
-                ...req.requestContext.meta,
-                metrics: { ...req.requestContext.meta?.metrics, cacheHit: true },
-            };
-        }
-        return res.send(response);
-    }
-    logger.debug('Did not find response in cache, moving to next middleware');
-};
-exports.buildCacheMiddleware = buildCacheMiddleware;