@chainlink/external-adapter-framework 0.0.22 → 0.0.25

package/examples/coingecko/test/integration/fixtures.js

@@ -1,41 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createMocks = void 0;
-const nock_1 = __importDefault(require("nock"));
-const capturedRequests_json_1 = __importDefault(require("./capturedRequests.json"));
-// This is a generic fixture file that can be copy-pasted to generate fixtures from a
-// capturedRequests.json file.  To generate a capturedRequests.json file,
-// set env var RECORD=true and run e2e tests.
-const createMocks = () => {
-    const mocks = [];
-    for (const baseUrl in capturedRequests_json_1.default) {
-        const mock = (0, nock_1.default)(baseUrl, { encodedQueryParams: true });
-        for (const request of capturedRequests_json_1.default[baseUrl]) {
-            if (request.method === 'GET') {
-                mock
-                    .get((uri) => {
-                    const deconstructedRequestUrl = uri.split(/[?=,&]+/);
-                    const deconstructedMockUrl = request.path.split(/[?=,&]+/);
-                    return (deconstructedRequestUrl.sort().join(',') === deconstructedMockUrl.sort().join(','));
-                })
-                    .times(100)
-                    .reply(request.statusCode, () => request.response, [
-                    'Content-Type',
-                    'application/json',
-                    'Connection',
-                    'close',
-                    'Vary',
-                    'Accept-Encoding',
-                    'Vary',
-                    'Origin',
-                ]);
-            }
-        }
-        mocks.push(mock);
-    }
-    return mocks;
-};
-exports.createMocks = createMocks;

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

@@ -1,7 +0,0 @@
-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

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

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

@@ -1,12 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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>) => Promise<FastifyInstance | undefined>;

package/metrics/constants.d.ts

@@ -1,16 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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" | "status_code" | "retry" | "is_cache_warming" | "feed_id" | "provider_status_code">;
-export declare const httpRequestDurationSeconds: client.Histogram<string>;

package/metrics/util.d.ts

@@ -1,7 +0,0 @@
-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/rate-limiting/background/fixed-frequency.d.ts

@@ -1,11 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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) => 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>) => AdapterRateLimitTier | undefined;

package/rate-limiting/metrics.d.ts

@@ -1,3 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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/test.d.ts

@@ -1 +0,0 @@
-export {};

package/test.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const _1 = require(".");
-const src_1 = require("./examples/coingecko/src");
-// Start sample adapter
-(0, _1.expose)(src_1.adapter);

package/transports/batch-warming.d.ts

@@ -1,35 +0,0 @@
-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

@@ -1,73 +0,0 @@
-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

@@ -1,22 +0,0 @@
-import * as client from 'prom-client';
-import { AdapterContext } from '../adapter';
-import { SettingsMap } from '../config';
-export declare const dataProviderMetricsLabel: (providerStatusCode?: number, 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

@@ -1,44 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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>>;

package/transports/websocket.d.ts

@@ -1,80 +0,0 @@
-import WebSocket from 'ws';
-import { AdapterContext, AdapterDependencies } from '../adapter';
-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 './';
-declare type WebSocketClass = new (url: string, protocols?: string | string[] | undefined) => WebSocket;
-export declare class WebSocketClassProvider {
-    static ctor: WebSocketClass;
-    static set(ctor: WebSocketClass): void;
-    static get(): WebSocketClass;
-}
-/**
- * Config object that is provided to the WebSocketTransport constructor.
- */
-export interface WebSocketTransportConfig<AdapterParams, ProviderDataMessage, CustomSettings extends SettingsMap> {
-    /** Endpoint to which to open the WS connection*/
-    url: string;
-    /** Map of handlers for different WS lifecycle events */
-    handlers: {
-        /**
-         * Handles when the WS is successfully opened
-         *
-         * @param wsConnection - the WebSocket with an established connection
-         * @returns an empty Promise, or void
-         */
-        open: (wsConnection: WebSocket, context: AdapterContext<CustomSettings>) => Promise<void> | void;
-        /**
-         * Handles when the WS receives a message
-         *
-         * @param message - the message received by the WS
-         * @param context - the background context for the Adapter
-         * @returns a list of cache entries of adapter responses to set in the cache
-         */
-        message: (message: ProviderDataMessage, context: AdapterContext<CustomSettings>) => ProviderResult<AdapterParams>[];
-    };
-    /** Map of "builders", functions that will be used to prepare specific WS messages */
-    builders: {
-        /**
-         * Builds a WS message that will be sent to subscribe to a specific feed
-         *
-         * @param params - the body of the adapter request
-         * @returns the WS message (can be any type as long as the [[WebSocket]] doesn't complain)
-         */
-        subscribeMessage: (params: AdapterParams) => unknown;
-        /**
-         * Builds a WS message that will be sent to unsubscribe to a specific feed
-         *
-         * @param params - the body of the adapter request
-         * @returns the WS message (can be any type as long as the [[WebSocket]] doesn't complain)
-         */
-        unsubscribeMessage: (params: AdapterParams) => unknown;
-    };
-}
-/**
- * Transport implementation that takes incoming requests, adds them to an [[subscriptionSet]] and,
- * through a WebSocket connection, subscribes to the relevant feeds to populate the cache.
- *
- * @typeParam AdapterParams - interface for the adapter request body
- * @typeParam ProviderDataMessage - interface for a WS message containing processable data (i.e. not part of open/close/login/etc)
- */
-export declare class WebSocketTransport<AdapterParams, ProviderDataMessage, CustomSettings extends SettingsMap> implements Transport<AdapterParams, null, CustomSettings> {
-    private config;
-    cache: Cache;
-    rateLimiter: BackgroundExecuteRateLimiter;
-    subscriptionSet: SubscriptionSet<AdapterParams>;
-    localSubscriptions: AdapterParams[];
-    wsConnection: WebSocket;
-    constructor(config: WebSocketTransportConfig<AdapterParams, ProviderDataMessage, CustomSettings>);
-    initialize(dependencies: AdapterDependencies): Promise<void>;
-    hasBeenSetUp(req: AdapterRequest<AdapterParams>): Promise<boolean>;
-    setup(req: AdapterRequest<AdapterParams>, config: AdapterConfig<CustomSettings>): Promise<void>;
-    serializeMessage(payload: unknown): string;
-    deserializeMessage(data: WebSocket.Data): ProviderDataMessage;
-    establishWsConnection(context: AdapterContext<CustomSettings>): Promise<unknown>;
-    backgroundExecute(context: AdapterContext<CustomSettings>): Promise<number>;
-}
-export {};

package/util/index.d.ts

@@ -1,12 +0,0 @@
-export * from './request';
-export * from './logger';
-export * from './subscription-set/subscription-set';
-/**
- * Sleeps for the provided number of milliseconds
- * @param ms - The number of milliseconds to sleep for
- * @returns a Promise that resolves once the specified time passes
- */
-export declare const sleep: (ms: number) => Promise<void>;
-export declare const isObject: (o: unknown) => boolean;
-export declare const isArray: (o: unknown) => boolean;
-export declare type PromiseOrValue<T> = Promise<T> | T;

package/util/logger.d.ts

@@ -1,42 +0,0 @@
-/// <reference types="node" />
-import pino from 'pino';
-import { AdapterRequest } from './request';
-import { FastifyReply, HookHandlerDoneFunction } from 'fastify';
-import { AsyncLocalStorage } from 'node:async_hooks';
-export declare const asyncLocalStorage: AsyncLocalStorage<unknown>;
-export declare type Store = {
-    correlationId: string;
-};
-/**
- * Instead of using a global logger instance, we want to force using a child logger
- * with a specific layer set in it, so that we can filter logs by where they're output from.
- *
- * Details on what each log level represents:
- * "trace": Forensic debugging of issues on a local machine.
- * "debug": Detailed logging level to get more context from users on their environments.
- * "info": High-level informational messages, to describe at a glance the high level state of the system.
- * "warn": A mild error occurred that might require non-urgent action.
- * "error": An unexpected error occurred during the regular operation of a well-maintained EA.
- * "fatal": The EA encountered an unrecoverable problem and had to exit.
- *
- * Full reference this is based on can be found at
- * https://github.com/smartcontractkit/documentation/blob/main/docs/Node%20Operators/configuration-variables.md#log_level
- *
- * @param layer - the layer name to include in the logs (e.g. "SomeMiddleware", "RedisCache", etc.)
- * @returns a layer specific logger
- */
-export declare const makeLogger: (layer: string) => pino.Logger<{
-    level: string;
-    mixin(): {};
-    transport: {
-        target: string;
-        options: {
-            levelFirst: boolean;
-            levelLabel: string;
-            ignore: string;
-            messageFormat: string;
-            translateTime: string;
-        };
-    } | undefined;
-} & pino.ChildLoggerOptions>;
-export declare const loggingContextMiddleware: (req: AdapterRequest, res: FastifyReply, done: HookHandlerDoneFunction) => void;