@chainlink/external-adapter-framework 0.0.7 → 0.0.10

package/validation/error.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdapterCustomError = exports.AdapterConnectionError = exports.AdapterDataProviderError = exports.AdapterTimeoutError = exports.AdapterRateLimitError = exports.AdapterInputError = exports.AdapterError = void 0;
+const constants_1 = require("../metrics/constants");
+class AdapterError extends Error {
+    constructor({ jobRunID = '1', status = 'errored', statusCode = 500, name = 'AdapterError', message = 'An error occurred.', cause, url, errorResponse, feedID, providerStatusCode, metricsLabel = constants_1.HttpRequestType.ADAPTER_ERROR }) {
+        super(message);
+        this.jobRunID = jobRunID;
+        this.status = status;
+        this.statusCode = statusCode;
+        this.name = name;
+        this.message = message;
+        this.cause = cause;
+        if (url) {
+            this.url = url;
+        }
+        if (feedID) {
+            this.feedID = feedID;
+        }
+        this.errorResponse = errorResponse;
+        this.providerStatusCode = providerStatusCode;
+        this.metricsLabel = metricsLabel;
+    }
+    toJSONResponse() {
+        const showDebugInfo = process.env['NODE_ENV'] === 'development' || process.env['DEBUG'] === 'true';
+        const errorBasic = {
+            name: this.name,
+            message: this.message,
+            url: this.url,
+            errorResponse: this.errorResponse,
+            feedID: this.feedID,
+        };
+        const errorFull = { ...errorBasic, stack: this.stack, cause: this.cause };
+        return {
+            jobRunID: this.jobRunID,
+            status: this.status,
+            statusCode: this.statusCode,
+            providerStatusCode: this.providerStatusCode,
+            error: showDebugInfo ? errorFull : errorBasic,
+        };
+    }
+}
+exports.AdapterError = AdapterError;
+class AdapterInputError extends AdapterError {
+    constructor(input) {
+        super({ ...input, metricsLabel: constants_1.HttpRequestType.INPUT_ERROR });
+    }
+}
+exports.AdapterInputError = AdapterInputError;
+class AdapterRateLimitError extends AdapterError {
+    constructor(input) {
+        super({ ...input, metricsLabel: constants_1.HttpRequestType.RATE_LIMIT_ERROR });
+    }
+}
+exports.AdapterRateLimitError = AdapterRateLimitError;
+class AdapterTimeoutError extends AdapterError {
+    constructor(input) {
+        super({ ...input, metricsLabel: constants_1.HttpRequestType.TIMEOUT_ERROR });
+    }
+}
+exports.AdapterTimeoutError = AdapterTimeoutError;
+class AdapterDataProviderError extends AdapterError {
+    constructor(input) {
+        super({ ...input, metricsLabel: constants_1.HttpRequestType.DP_ERROR });
+    }
+}
+exports.AdapterDataProviderError = AdapterDataProviderError;
+class AdapterConnectionError extends AdapterError {
+    constructor(input) {
+        super({ ...input, metricsLabel: constants_1.HttpRequestType.CONNECTION_ERROR });
+    }
+}
+exports.AdapterConnectionError = AdapterConnectionError;
+class AdapterCustomError extends AdapterError {
+    constructor(input) {
+        super({ ...input, metricsLabel: constants_1.HttpRequestType.CUSTOM_ERROR });
+    }
+}
+exports.AdapterCustomError = AdapterCustomError;

package/validation/index.d.ts

@@ -0,0 +1,5 @@
+import { FastifyReply, FastifyRequest } from 'fastify';
+import { AdapterMiddlewareBuilder } from '../util/request';
+export { InputParameters } from './input-params';
+export declare const validatorMiddleware: AdapterMiddlewareBuilder;
+export declare const errorCatchingMiddleware: (err: Error, req: FastifyRequest, res: FastifyReply) => void;

package/{dist/src/validation → validation}/index.js

@@ -10,13 +10,13 @@ const override_functions_1 = require("./override-functions");
 const errorCatcherLogger = (0, util_2.makeLogger)('ErrorCatchingMiddleware');
 const validatorMiddleware = (adapter) => (req, reply, done) => {
     if (req.headers['content-type'] !== 'application/json') {
-        throw new error_1.AdapterError({
+        throw new error_1.AdapterInputError({
             message: 'Content type not "application/json", returning 400',
             statusCode: 400,
         });
     }
     if (!req.body) {
-        throw new error_1.AdapterError({
+        throw new error_1.AdapterInputError({
             message: 'Body not present in adapter request, returning 400',
             statusCode: 400,
         });
@@ -24,14 +24,14 @@ const validatorMiddleware = (adapter) => (req, reply, done) => {
     // Make endpoints case insensitive
     const endpointParam = req.body.endpoint?.toLowerCase() || adapter.defaultEndpoint;
     if (!endpointParam) {
-        throw new error_1.AdapterError({
+        throw new error_1.AdapterInputError({
             message: `Request body does not specify an endpoint, and there is no default endpoint configured for this adapter.`,
             statusCode: 400,
         });
     }
     const endpoint = adapter.endpointsMap[endpointParam];
     if (!endpoint) {
-        throw new error_1.AdapterError({
+        throw new error_1.AdapterInputError({
             message: `Adapter does not have a "${req.body.endpoint}" endpoint.`,
             statusCode: 404,
         });
@@ -48,8 +48,8 @@ const validatorMiddleware = (adapter) => (req, reply, done) => {
     if (adapter.config.METRICS_ENABLED && adapter.config.EXPERIMENTAL_METRICS_ENABLED) {
         // Add metrics meta which includes feedId to the request
         // Perform prior to overrides to maintain consistent Feed IDs across adapters
-        const metricsMeta = (0, util_1.getMetricsMeta)(endpoint, validator.validated.data);
-        req.requestContext = { ...req.requestContext, metricsMeta };
+        const metrics = (0, util_1.getMetricsMeta)(endpoint, validator.validated.data);
+        req.requestContext = { ...req.requestContext, meta: { metrics } };
     }
     // TODO: Support `includes` and `tokenOverrides` overrides as needed
     const requestParams = req.requestContext.data ?? {};
@@ -70,6 +70,8 @@ const validatorMiddleware = (adapter) => (req, reply, done) => {
 };
 exports.validatorMiddleware = validatorMiddleware;
 const errorCatchingMiddleware = (err, req, res) => {
+    // Add adapter or generic error to request meta for metrics use
+    req.requestContext.meta = { ...req.requestContext.meta, error: err };
     if (err instanceof error_1.AdapterError) {
         // We want to log these as warn, because although they are to be expected, NOPs should
         // Only use "correct" job specs and therefore not hit adapters with invalid requests.

package/validation/input-params.d.ts

@@ -0,0 +1,15 @@
+export declare type Override = Map<string, Map<string, string>>;
+export declare type InputParameter = {
+    aliases?: string[];
+    description?: string;
+    type?: 'bigint' | 'boolean' | 'array' | 'number' | 'object' | 'string';
+    required?: boolean;
+    options?: unknown[];
+    default?: unknown;
+    dependsOn?: string[];
+    exclusive?: string[];
+};
+export declare type InputParameters = {
+    [name: string]: InputParameter | boolean | string[];
+};
+export declare const baseInputParameters: InputParameters;

package/validation/override-functions.d.ts

@@ -0,0 +1,3 @@
+import { InitializedAdapter } from '../adapter';
+import { AdapterRequest } from '../util/request';
+export declare const performSymbolOverrides: (adapter: InitializedAdapter, req: AdapterRequest) => void;

package/validation/validator.d.ts

@@ -0,0 +1,47 @@
+import { AdapterError, AdapterErrorResponse } from './error';
+import { InputParameters, Override } from './input-params';
+export declare type OverrideType = 'overrides' | 'tokenOverrides' | 'includes';
+declare type InputType = {
+    id?: string;
+    data?: any;
+};
+export interface ValidatorOptions {
+    shouldThrowError?: boolean;
+    includes?: any[];
+    overrides?: any;
+}
+export declare type IncludePair = {
+    from: string;
+    to: string;
+    adapters?: string[];
+    inverse?: boolean;
+    tokens?: boolean;
+};
+export declare type Includes = {
+    from: string;
+    to: string;
+    includes: IncludePair[];
+};
+export declare class Validator {
+    input: InputType;
+    inputConfigs: InputParameters;
+    inputOptions: Record<string, any[]>;
+    validatorOptions: ValidatorOptions;
+    validated: any;
+    error: AdapterError | undefined;
+    errored: AdapterErrorResponse | undefined;
+    constructor(input?: InputType, inputConfigs?: {}, inputOptions?: {}, validatorOptions?: ValidatorOptions);
+    validateInput(): void;
+    validateOverrides(path: 'overrides' | 'tokenOverrides', preset: Record<string, any>): void;
+    checkDuplicateInputParams(inputConfig: InputParameters): void;
+    validateIncludeOverrides(): void;
+    parseError(error: unknown): void;
+    formatOverride: (param: any) => Override;
+    formatIncludeOverrides: (param: any) => Override;
+    throwInvalid: (message: string) => void;
+    validateObjectParam(key: string, shouldThrowError?: boolean): void;
+    validateOptionalParam(param: any, key: string, options: any[]): void;
+    validateRequiredParam(param: any, key: string, options: any[]): void;
+    getUsedKey(key: string, keyArray: string[]): string | undefined;
+}
+export {};

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/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/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;