@chainlink/external-adapter-framework 0.0.25 → 0.0.27

package/examples/coingecko/src/cryptoUtils.d.ts

@@ -0,0 +1,31 @@
+import { AxiosRequestConfig, AxiosResponse } from 'axios';
+import { AdapterConfig } from '../../../config';
+import { InputParameters } from '../../../validation';
+export interface CryptoRequestParams {
+    coinid?: string;
+    base?: string;
+    quote: string;
+}
+export declare const cryptoInputParams: InputParameters;
+export interface ProviderRequestBody {
+    ids: string;
+    vs_currencies: string;
+    include_market_cap?: boolean;
+    include_24hr_vol?: boolean;
+}
+export interface ProviderResponseBody {
+    [base: string]: {
+        [quote: string]: number;
+    };
+}
+interface ResultEntryWithoutOverrides {
+    value: number;
+    params: {
+        quote: string;
+        base?: string;
+        coinid?: string;
+    };
+}
+export declare const buildBatchedRequestBody: (params: CryptoRequestParams[], config: AdapterConfig) => AxiosRequestConfig<ProviderRequestBody>;
+export declare const constructEntry: (res: AxiosResponse<ProviderResponseBody>, requestPayload: CryptoRequestParams, resultPath: string) => ResultEntryWithoutOverrides | undefined;
+export {};

package/examples/coingecko/src/endpoint/coins.d.ts

@@ -0,0 +1,9 @@
+import { AdapterEndpoint } from '../../../../../src/adapter';
+import { InputParameters } from '../../../../../src/validation';
+export declare const inputParameters: InputParameters;
+export interface CoinsResponse {
+    id: string;
+    symbol: string;
+    name: string;
+}
+export declare const endpoint: AdapterEndpoint<import("../../../../util/request").AdapterRequestData, CoinsResponse[], import("../../../../config").SettingsMap>;

package/examples/coingecko/src/endpoint/crypto-marketcap.d.ts

@@ -0,0 +1,3 @@
+import { AdapterEndpoint } from '../../../../adapter';
+import { CryptoRequestParams } from '../cryptoUtils';
+export declare const endpoint: AdapterEndpoint<CryptoRequestParams, unknown, import("../../../../config").SettingsMap>;

package/examples/coingecko/src/endpoint/crypto-volume.d.ts

@@ -0,0 +1,3 @@
+import { AdapterEndpoint } from '../../../../adapter';
+import { CryptoRequestParams } from '../cryptoUtils';
+export declare const endpoint: AdapterEndpoint<CryptoRequestParams, unknown, import("../../../../config").SettingsMap>;

package/examples/coingecko/src/endpoint/crypto.d.ts

@@ -0,0 +1,3 @@
+import { AdapterEndpoint } from '../../../../adapter';
+import { CryptoRequestParams } from '../cryptoUtils';
+export declare const endpoint: AdapterEndpoint<CryptoRequestParams, unknown, import("../../../../config").SettingsMap>;

package/examples/coingecko/src/endpoint/dominance.d.ts

@@ -0,0 +1,3 @@
+import { AdapterEndpoint } from '../../../../adapter';
+import { AdapterRequestParams } from '../globalUtils';
+export declare const endpoint: AdapterEndpoint<AdapterRequestParams, unknown, import("../../../../config").SettingsMap>;

package/examples/coingecko/src/endpoint/global-marketcap.d.ts

@@ -0,0 +1,3 @@
+import { AdapterEndpoint } from '../../../../adapter';
+import { AdapterRequestParams } from '../globalUtils';
+export declare const endpoint: AdapterEndpoint<AdapterRequestParams, unknown, import("../../../../config").SettingsMap>;

package/examples/coingecko/src/endpoint/index.d.ts

@@ -0,0 +1,6 @@
+export { endpoint as coins } from './coins';
+export { endpoint as crypto } from './crypto';
+export { endpoint as cryptoMarketcap } from './crypto-marketcap';
+export { endpoint as globalMarketcap } from './global-marketcap';
+export { endpoint as dominance } from './dominance';
+export { endpoint as cryptoVolume } from './crypto-volume';

package/examples/coingecko/src/globalUtils.d.ts

@@ -0,0 +1,27 @@
+import { AxiosRequestConfig, AxiosResponse } from 'axios';
+import { InputParameters } from '../../../validation';
+export declare const inputParameters: InputParameters;
+export interface AdapterRequestParams {
+    market: string;
+}
+export interface ProviderResponseBody {
+    data: {
+        active_cryptocurrencies: number;
+        upcoming_icos: number;
+        ongoing_icos: number;
+        ended_icos: number;
+        markets: number;
+        total_market_cap: Record<string, number>;
+        total_volume: Record<string, number>;
+        market_cap_percentage: Record<string, number>;
+        market_cap_change_percentage_24h_usd: number;
+        updated_at: number;
+    };
+}
+interface ResultEntry {
+    value: number;
+    params: AdapterRequestParams;
+}
+export declare const buildGlobalRequestBody: (apiKey?: string | undefined) => AxiosRequestConfig<never>;
+export declare const constructEntry: (res: AxiosResponse<ProviderResponseBody>, requestPayload: AdapterRequestParams, resultPath: 'total_market_cap' | 'market_cap_percentage') => ResultEntry | undefined;
+export {};

package/examples/coingecko/src/index.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+import { Adapter } from '../../../../src/adapter';
+export declare const adapter: Adapter<import("../../../config").SettingsMap>;
+export declare const server: () => Promise<import("fastify").FastifyInstance<import("http").Server, import("http").IncomingMessage, import("http").ServerResponse, import("fastify").FastifyLoggerInstance> | undefined>;

package/examples/coingecko-old/batch-warming.d.ts

@@ -0,0 +1,7 @@
+import { AdapterEndpoint } from '../../adapter';
+interface AdapterRequestParams {
+    base: string;
+    quote: string;
+}
+export declare const batchEndpoint: AdapterEndpoint<AdapterRequestParams, unknown, import("../../config").SettingsMap>;
+export {};

package/examples/coingecko-old/index.d.ts

@@ -0,0 +1,2 @@
+import { Adapter } from '../../adapter';
+export declare const adapter: Adapter<import("../../config").SettingsMap>;

package/examples/coingecko-old/rest.d.ts

@@ -0,0 +1,12 @@
+import { AdapterEndpoint } from '../../adapter';
+interface AdapterRequestParams {
+    base: string;
+    quote: string;
+}
+interface ProviderResponseBody {
+    [base: string]: {
+        [quote: string]: number;
+    };
+}
+export declare const restEndpoint: AdapterEndpoint<AdapterRequestParams, ProviderResponseBody, import("../../config").SettingsMap>;
+export {};

package/examples/ncfx/config/index.d.ts

@@ -0,0 +1,12 @@
+export declare const customSettings: {
+    readonly USERNAME: {
+        readonly description: "Username for the NCFX API";
+        readonly type: "string";
+        readonly required: true;
+    };
+    readonly PASSWORD: {
+        readonly description: "Password for the NCFX API";
+        readonly type: "string";
+        readonly required: true;
+    };
+};

package/examples/ncfx/index.d.ts

@@ -0,0 +1,13 @@
+import { Adapter } from '../../adapter';
+export declare const adapter: Adapter<{
+    readonly USERNAME: {
+        readonly description: "Username for the NCFX API";
+        readonly type: "string";
+        readonly required: true;
+    };
+    readonly PASSWORD: {
+        readonly description: "Password for the NCFX API";
+        readonly type: "string";
+        readonly required: true;
+    };
+}>;

package/examples/ncfx/websocket.d.ts

@@ -0,0 +1,47 @@
+import { AdapterEndpoint } from '../../adapter';
+import { WebSocketTransport } from '../../transports/websocket';
+import { InputParameters } from '../../validation';
+interface AdapterRequestParams {
+    base: string;
+    quote: string;
+}
+export declare const inputParameters: InputParameters;
+interface ProviderMessage {
+    timestamp: string;
+    currencyPair: string;
+    bid: number;
+    offer: number;
+    mid: number;
+    changes: [
+        {
+            period: string;
+            change: number;
+            percentage: number;
+        }
+    ];
+}
+export declare const websocketTransport: WebSocketTransport<AdapterRequestParams, ProviderMessage[], {
+    readonly USERNAME: {
+        readonly description: "Username for the NCFX API";
+        readonly type: "string";
+        readonly required: true;
+    };
+    readonly PASSWORD: {
+        readonly description: "Password for the NCFX API";
+        readonly type: "string";
+        readonly required: true;
+    };
+}>;
+export declare const webSocketEndpoint: AdapterEndpoint<AdapterRequestParams, unknown, {
+    readonly USERNAME: {
+        readonly description: "Username for the NCFX API";
+        readonly type: "string";
+        readonly required: true;
+    };
+    readonly PASSWORD: {
+        readonly description: "Password for the NCFX API";
+        readonly type: "string";
+        readonly required: true;
+    };
+}>;
+export {};

package/index.d.ts

@@ -0,0 +1,11 @@
+import { FastifyInstance } from 'fastify';
+import { Adapter, AdapterDependencies } from './adapter';
+/**
+ * Main function for the framework.
+ * Initializes config and dependencies, uses those to initialize Transports, and starts listening for requests.
+ *
+ * @param adapter - an object describing an External Adapter
+ * @param dependencies - an optional object with adapter dependencies to inject
+ * @returns a Promise that resolves to the http.Server listening for connections
+ */
+export declare const expose: (adapter: Adapter, dependencies?: Partial<AdapterDependencies> | undefined) => Promise<FastifyInstance | undefined>;

package/metrics/constants.d.ts

@@ -0,0 +1,16 @@
+export declare enum HttpRequestType {
+    CACHE_HIT = "cacheHit",
+    DATA_PROVIDER_HIT = "dataProviderHit",
+    ADAPTER_ERROR = "adapterError",
+    INPUT_ERROR = "inputError",
+    RATE_LIMIT_ERROR = "rateLimitError",
+    DP_ERROR = "dataProviderError",
+    TIMEOUT_ERROR = "timeoutError",
+    CONNECTION_ERROR = "connectionError",
+    CUSTOM_ERROR = "customError"
+}
+/**
+ * Maxiumum number of characters that a feedId can contain.
+ */
+export declare const MAX_FEED_ID_LENGTH = 300;
+export declare const requestDurationBuckets: number[];

package/metrics/index.d.ts

@@ -0,0 +1,15 @@
+import * as client from 'prom-client';
+import { AdapterRequest } from '../util';
+import { AdapterConfig } from '../config';
+import { FastifyReply, HookHandlerDoneFunction } from 'fastify';
+export declare function setupMetricsServer(name: string, config: AdapterConfig): void;
+export declare const setupMetrics: (name: string, config: AdapterConfig) => void;
+/**
+ * Builds metrics middleware that records end to end EA response times
+ * and count of requests
+ *
+ * @returns the cache middleware function
+ */
+export declare const buildMetricsMiddleware: (req: AdapterRequest, res: FastifyReply, done: HookHandlerDoneFunction) => void;
+export declare const httpRequestsTotal: client.Counter<"type" | "method" | "feed_id" | "status_code" | "provider_status_code" | "retry" | "is_cache_warming">;
+export declare const httpRequestDurationSeconds: client.Histogram<string>;

package/metrics/util.d.ts

@@ -0,0 +1,7 @@
+import { AdapterMetricsMeta, AdapterRequestData } from '../util';
+import { AdapterEndpoint } from '../adapter';
+import { AdapterConfig, SettingsMap } from '../config';
+export declare const getMetricsMeta: <Params, Result, CustomSettings extends SettingsMap>({ adapterEndpoint, adapterConfig, }: {
+    adapterEndpoint: AdapterEndpoint<Params, Result, CustomSettings>;
+    adapterConfig: AdapterConfig<CustomSettings>;
+}, data: AdapterRequestData) => AdapterMetricsMeta;

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@chainlink/external-adapter-framework",
-  "version": "0.0.25",
+  "version": "0.0.27",
   "main": "dist/index.js",
   "license": "MIT",
   "dependencies": {
+    "ajv": "^8.11.0",
     "axios": "^0.27.2",
     "fastify": "^4.5.3",
     "ioredis": "^5.0.4",

package/rate-limiting/background/fixed-frequency.d.ts

@@ -0,0 +1,11 @@
+import { AdapterRateLimitTier, BackgroundExecuteRateLimiter } from '..';
+import { AdapterEndpoint } from '../../adapter';
+import { SettingsMap } from '../../config';
+export declare const DEFAULT_SHARED_MS_BETWEEN_REQUESTS = 5000;
+export declare class FixedFrequencyRateLimiter implements BackgroundExecuteRateLimiter {
+    msBetweenRequestsMap: {
+        [endpointName: string]: number;
+    };
+    initialize<Params, Result, CustomSettings extends SettingsMap>(endpoints: AdapterEndpoint<Params, Result, CustomSettings>[], limits?: AdapterRateLimitTier): this;
+    msUntilNextExecution(endpointName: string): number;
+}

package/rate-limiting/index.d.ts

@@ -0,0 +1,55 @@
+import { AdapterEndpoint } from '../adapter';
+import { AdapterConfig, SettingsMap } from '../config';
+export * from './request/simple-counting';
+export * from './background/fixed-frequency';
+export interface AdapterRateLimitTier {
+    rateLimit1s?: number;
+    rateLimit1m?: number;
+    rateLimit1h?: number;
+    note?: string;
+}
+/**
+ * Common interface for all RateLimiter classes to implement
+ */
+export interface RateLimiter {
+    /**
+     * Method to ensure all RateLimiters can be initialized in the same manner.
+     *
+     * @param limits - settings for how much throughput to allow for the Adapter
+     * @param endpoints - list of adapter endpoints
+     */
+    initialize<Params, Result, CustomSettings extends SettingsMap>(endpoints: AdapterEndpoint<Params, Result, CustomSettings>[], limits: AdapterRateLimitTier): this;
+}
+/**
+ * RequestRateLimiters perform checks agains imminent outbound requests for any transport.
+ */
+export interface RequestRateLimiter extends RateLimiter {
+    /**
+     * This method will check using whatever strategy is implemented to determine if
+     * this request can be processed. If so, it returns true; if not, returns false.
+     */
+    isUnderLimits(): boolean;
+}
+/**
+ * BackgroundExecuteFrequencyRateLimiters will implement custom logic to calculate
+ * the period of time to wait between background executions for a transport.
+ */
+export interface BackgroundExecuteRateLimiter extends RateLimiter {
+    msUntilNextExecution(endpointName: string): number;
+}
+/**
+ * This method will convert all possible settings for a rate limit tier and
+ * convert them all to requests per second, returning the lowest one
+ *
+ * @param limits - the rate limit tier set for the adapter
+ * @returns the most restrictive of the set options, in requests per second
+ */
+export declare const consolidateTierLimits: (limits?: AdapterRateLimitTier | undefined) => number;
+/**
+ * Validates rate limiting tiers specified for the adapter, and returns the one to use.
+ *
+ * @param config - the adapter config containing the env vars
+ * @param tiers - the adapter config listing the different available API tiers
+ * @returns the specified API tier, or a default one if none are specified
+ */
+export declare const getRateLimitingTier: (config: AdapterConfig, tiers?: Record<string, AdapterRateLimitTier> | undefined) => AdapterRateLimitTier | undefined;

package/rate-limiting/metrics.d.ts

@@ -0,0 +1,3 @@
+import * as client from 'prom-client';
+export declare const retrieveCost: <ProviderResponseBody>(data: ProviderResponseBody) => number;
+export declare const rateLimitCreditsSpentTotal: client.Counter<"feed_id" | "participant_id">;

package/rate-limiting/request/simple-counting.d.ts

@@ -0,0 +1,21 @@
+import { AdapterRateLimitTier, RateLimiter } from '..';
+import { AdapterEndpoint } from '../../adapter';
+import { SettingsMap } from '../../config';
+/**
+ * This rate limiter is the simplest stateful option.
+ * On startup, it'll compare the different thresholds for each tier, calculate them all
+ * in the finest window we'll use (seconds), and use the most restrictive one.
+ * This is so if the EA were to restart, we don't need to worry about persisting state
+ * for things like daily quotas. The downside is that this does not work well for bursty
+ * loads or spikes, in cases where e.g. the per second limit is high but daily quotas low.
+ */
+export declare class SimpleCountingRateLimiter implements RateLimiter {
+    latestSecondInterval: number;
+    requestsThisSecond: number;
+    latestMinuteInterval: number;
+    requestsThisMinute: number;
+    perSecondLimit: number;
+    perMinuteLimit: number;
+    initialize<Params, Result, CustomSettings extends SettingsMap>(endpoints: AdapterEndpoint<Params, Result, CustomSettings>[], limits?: AdapterRateLimitTier): this;
+    isUnderLimits(): boolean;
+}

package/transports/batch-warming.d.ts

@@ -0,0 +1,35 @@
+import { AxiosRequestConfig, AxiosResponse } from 'axios';
+import { Cache } from '../cache';
+import { AdapterConfig, SettingsMap } from '../config';
+import { BackgroundExecuteRateLimiter } from '../rate-limiting';
+import { SubscriptionSet } from '../util';
+import { AdapterRequest, ProviderResult } from '../util/request';
+import { Transport } from './';
+import { AdapterContext, AdapterDependencies } from '../adapter';
+/**
+ * Transport implementation that takes incoming batches requests and keeps a warm cache of values.
+ * Within the setup function, adapter params are added to an set that also keeps track and expires values.
+ * In the background execute, the list of non-expired items in the set is fetched.
+ * Then, the list is passed through the `prepareRequest` function, that returns an AxiosRequestConfig.
+ * The Data Provider response is, they are passed through the `parseResponse` function to create a [[CacheEntry]] list.
+ * Finally, the items in that [[CacheEntry]] list are set in the Cache so the Adapter can fetch values from there.
+ *
+ * @typeParam AdapterParams - interface for the adapter request body
+ * @typeParam ProviderRequestBody - interface for the body of the request to the Data Provider
+ * @typeParam ProviderResponseBody - interface for the body of the Data Provider's response
+ */
+export declare class BatchWarmingTransport<AdapterParams, ProviderRequestBody, ProviderResponseBody, CustomSettings extends SettingsMap> implements Transport<AdapterParams, ProviderResponseBody, CustomSettings> {
+    private config;
+    cache: Cache;
+    rateLimiter: BackgroundExecuteRateLimiter;
+    subscriptionSet: SubscriptionSet<AdapterParams>;
+    WARMER_ACTIVE: boolean;
+    constructor(config: {
+        prepareRequest: (params: AdapterParams[], context: AdapterContext<CustomSettings>) => AxiosRequestConfig<ProviderRequestBody>;
+        parseResponse: (params: AdapterParams[], res: AxiosResponse<ProviderResponseBody>, context: AdapterContext<CustomSettings>) => ProviderResult<AdapterParams>[];
+    });
+    initialize(dependencies: AdapterDependencies): Promise<void>;
+    hasBeenSetUp(req: AdapterRequest<AdapterParams>): Promise<boolean>;
+    setup(req: AdapterRequest<AdapterParams>, config: AdapterConfig<CustomSettings>): Promise<void>;
+    backgroundExecute(context: AdapterContext<CustomSettings>): Promise<number>;
+}

package/transports/index.d.ts

@@ -0,0 +1,73 @@
+import { FastifyReply } from 'fastify';
+import { AdapterContext, AdapterDependencies, Adapter } from '../adapter';
+import { CacheEntry } from '../cache';
+import { AdapterConfig, SettingsMap } from '../config';
+import { AdapterRequest, AdapterResponse, ProviderResult } from '../util/request';
+export * from './batch-warming';
+export * from './rest';
+export * from './websocket';
+/**
+ * Generic interface for a Transport.
+ * A Transport defines the way in which an AdapterEndpoint will process incoming requests to
+ * fetch data from a Data Provider. The setup phase will take care of the former, while the
+ * backgroundExecute will be in charge of the latter.
+ * This separation gives us the ability of splitting these concerns, and optionally parallelizing
+ * the reading and writing of data to a centralized Cache.
+ *
+ * @typeParam Params - the structure of the AdapterRequest's body
+ * @typeParam Result - the structure of the AdapterResponse's body
+ */
+export interface Transport<Params, Result, CustomSettings extends SettingsMap> {
+    /**
+     * Initializes the transport in the Adapter context.
+     *
+     * @param dependencies - Adapter dependencies (e.g. cache instance)
+     * @param config - Adapter config containing env vars
+     * @returns an empty Promise
+     */
+    initialize: (dependencies: AdapterDependencies, config: AdapterConfig) => Promise<void>;
+    /**
+     * Checks if the Transport has already set up the incoming request.
+     * This will likely use the cacheKey generated in the provided request.
+     *
+     * @param req - the incoming AdapterRequest
+     * @returns a Promise that returns true if setup is in place
+     */
+    hasBeenSetUp: (req: AdapterRequest<Params>) => Promise<boolean>;
+    /**
+     * Sets up the incoming request within the Transport.
+     * In other words, it means that the Adapter has recognized this request, and will begin
+     * fetching the necessary data from a Data Provider.
+     *
+     * @param req - the incoming AdapterRequest
+     * @param config - common configuration for the Adapter as a whole
+     * @returns a Promise that _optionally_ returns an AdapterResponse, if the Transport has the capability of
+     *   immediately fetching data and returning it without the background process.
+     */
+    setup: (req: AdapterRequest<Params>, config: AdapterConfig<CustomSettings>) => Promise<AdapterResponse<Result> | void>;
+    /**
+     * If the Transport relies on an async mechanism, implementing this function will make it
+     * so the background task executor calls it on Adapter startup.
+     *
+     * @param context - background context for the execution (e.g. endpoint name)
+     */
+    backgroundExecute?: (context: AdapterContext<CustomSettings>) => Promise<number>;
+}
+/**
+ * Helper method to build cache entries to set after getting a bunch of responses from a DP.
+ *
+ * @param results - a list of results coming from a DataProvider
+ * @param context - context for the Adapter
+ * @returns a list of CacheEntries of AdapterResponses
+ */
+export declare const buildCacheEntriesFromResults: <Params, CustomSettings extends SettingsMap>(results: ProviderResult<Params>[], context: AdapterContext<CustomSettings>) => CacheEntry<AdapterResponse<{
+    result: unknown;
+}>>[];
+/**
+ * Takes an Adapter, its configuration, and its dependencies, and it creates an express middleware
+ * that will pass along the AdapterRequest to the appropriate Transport (acc. to the endpoint in the req.)
+ *
+ * @param adapter - main adapter object, already initialized
+ * @returns the transport handler middleware function
+ */
+export declare const buildTransportHandler: (adapter: Adapter) => (req: AdapterRequest, reply: FastifyReply) => Promise<never>;

package/transports/metrics.d.ts

@@ -0,0 +1,22 @@
+import * as client from 'prom-client';
+import { AdapterContext } from '../adapter';
+import { SettingsMap } from '../config';
+export declare const dataProviderMetricsLabel: (providerStatusCode?: number | undefined, method?: string) => {
+    provider_status_code: number | undefined;
+    method: string;
+};
+export declare const dataProviderRequests: client.Counter<"method" | "provider_status_code">;
+export declare const dataProviderRequestDurationSeconds: client.Histogram<string>;
+export declare const connectionErrorLabels: (message: string) => {
+    message: string;
+};
+export declare const messageSubsLabels: (feed_id: string, cache_key: string) => {
+    feed_id: string;
+    subscription_key: string;
+};
+export declare const recordWsMessageMetrics: <AdapterParams, CustomSettings extends SettingsMap>(context: AdapterContext<CustomSettings>, subscribes: AdapterParams[], unsubscrices: AdapterParams[]) => void;
+export declare const wsConnectionActive: client.Gauge<"url">;
+export declare const wsConnectionErrors: client.Counter<"message" | "url">;
+export declare const wsSubscriptionActive: client.Gauge<"feed_id" | "connection_url" | "subscription_key">;
+export declare const wsSubscriptionTotal: client.Counter<"feed_id" | "connection_url" | "subscription_key">;
+export declare const wsMessageTotal: client.Counter<"feed_id" | "subscription_key">;

package/transports/rest.d.ts

@@ -0,0 +1,44 @@
+import { AdapterRequest, AdapterResponse } from '../util/request';
+import { Transport } from './';
+import { Cache } from '../cache';
+import { AxiosRequestConfig, AxiosResponse } from 'axios';
+import { AdapterConfig, SettingsMap } from '../config';
+import { RequestRateLimiter } from '../rate-limiting';
+import { AdapterDependencies } from '../adapter';
+/**
+ * Transport implementation that takes incoming requests, transforms them into a DataProvider request,
+ * and executes that request returning the response immediately from the `setup` function.
+ * Optionally, setting the `coalescing` option to `true` will make it so once a request is in flight,
+ * new adapter requests for the same feed will not trigger a new one, but return an empty promise from
+ * the setup instead so the normal cache polling mechanism is used.
+ *
+ * @typeParam AdapterParams - interface for the adapter request body
+ * @typeParam ProviderRequestBody - interface for the body of the request to the Data Provider
+ * @typeParam ProviderResponseBody - interface for the body of the Data Provider's response
+ */
+export declare class RestTransport<AdapterParams, ProviderRequestBody, ProviderResponseBody, CustomSettings extends SettingsMap> implements Transport<AdapterParams, ProviderResponseBody, CustomSettings> {
+    protected config: {
+        prepareRequest: (req: AdapterRequest<AdapterParams>, config: AdapterConfig<CustomSettings>) => AxiosRequestConfig<ProviderRequestBody> | Promise<AxiosRequestConfig<ProviderRequestBody>>;
+        parseResponse: (req: AdapterRequest<AdapterParams>, res: AxiosResponse<ProviderResponseBody>, config: AdapterConfig<CustomSettings>) => AdapterResponse<ProviderResponseBody> | Promise<AdapterResponse<ProviderResponseBody>>;
+        options: {
+            coalescing: boolean;
+        };
+    };
+    inFlightPrefix: string;
+    cache: Cache;
+    rateLimiter: RequestRateLimiter;
+    constructor(config: {
+        prepareRequest: (req: AdapterRequest<AdapterParams>, config: AdapterConfig<CustomSettings>) => AxiosRequestConfig<ProviderRequestBody> | Promise<AxiosRequestConfig<ProviderRequestBody>>;
+        parseResponse: (req: AdapterRequest<AdapterParams>, res: AxiosResponse<ProviderResponseBody>, config: AdapterConfig<CustomSettings>) => AdapterResponse<ProviderResponseBody> | Promise<AdapterResponse<ProviderResponseBody>>;
+        options: {
+            coalescing: boolean;
+        };
+    });
+    initialize(dependencies: AdapterDependencies, config: AdapterConfig): Promise<void>;
+    hasBeenSetUp(req: AdapterRequest<AdapterParams>): Promise<boolean>;
+    protected waitUntilUnderRateLimit(options: {
+        maxRetries: number;
+        msBetweenRetries: number;
+    }, retry?: number): Promise<void>;
+    setup(req: AdapterRequest<AdapterParams>, config: AdapterConfig<CustomSettings>): Promise<AdapterResponse<ProviderResponseBody> | undefined>;
+}

package/transports/util.d.ts

@@ -0,0 +1,9 @@
+import { AxiosRequestConfig, AxiosResponse } from 'axios';
+import { AdapterConfig, SettingsMap } from '../config';
+/**
+ * Performs axios request along with metrics recording and error handling
+ *
+ * @param request - axios request config
+ * @returns axios response for the request
+ */
+export declare function axiosRequest<ProviderRequestBody, ProviderResponseBody, CustomSettings extends SettingsMap>(request: AxiosRequestConfig<ProviderRequestBody>, config: AdapterConfig<CustomSettings>): Promise<AxiosResponse<ProviderResponseBody>>;