@chainlink/external-adapter-framework 0.0.8 → 0.0.12

package/{package → dist/src}/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chainlink/external-adapter-framework",
-  "version": "0.0.8",
+  "version": "0.0.6",
   "main": "dist/index.js",
   "license": "MIT",
   "dependencies": {
@@ -37,7 +37,10 @@
     "nock": "^13.2.4",
     "pino-pretty": "^7.6.0",
     "prettier": "^2.6.1",
-    "typedoc": "^0.22.15"
+    "ts-loader": "^9.3.1",
+    "typedoc": "^0.22.15",
+    "webpack": "^5.74.0",
+    "webpack-cli": "^4.10.0"
   },
   "prettier": {
     "semi": false,

package/{rate-limiting → dist/src/rate-limiting}/background/fixed-frequency.d.ts

@@ -1,10 +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(endpoints: AdapterEndpoint[], limits?: AdapterRateLimitTier): this;
+    initialize<Params, Result, CustomSettings extends SettingsMap>(endpoints: AdapterEndpoint<Params, Result, CustomSettings>[], limits?: AdapterRateLimitTier): this;
     msUntilNextExecution(endpointName: string): number;
 }

package/{rate-limiting → dist/src/rate-limiting}/background/fixed-frequency.js

@@ -19,11 +19,9 @@ class FixedFrequencyRateLimiter {
         }
         logger.debug('Using fixed frequency batch rate limiting');
         for (const endpoint of endpoints) {
-            // TODO: See if we can remove this runtime check
             if (endpoint.rateLimiting?.allocationPercentage == null) {
                 throw new Error(`Allocation percentage for endpoint "${endpoint.name}" is null`);
             }
-            // TODO: Implement different strategy where this is not fixed, but rather divided based on whether all warmers are active
             this.msBetweenRequestsMap[endpoint.name] =
                 (sharedMsBetweenRequests / endpoint.rateLimiting?.allocationPercentage) * 100;
             logger.debug(`Endpoint [${endpoint.name}]: ${this.msBetweenRequestsMap[endpoint.name] / 1000}s between requests`);

package/{rate-limiting → dist/src/rate-limiting}/index.d.ts

@@ -1,4 +1,5 @@
 import { AdapterEndpoint } from '../adapter';
+import { SettingsMap } from '../config';
 export * from './request/simple-counting';
 export * from './background/fixed-frequency';
 export interface AdapterRateLimitTier {
@@ -17,7 +18,7 @@ export interface RateLimiter {
      * @param limits - settings for how much throughput to allow for the Adapter
      * @param endpoints - list of adapter endpoints
      */
-    initialize(endpoints: AdapterEndpoint[], limits: AdapterRateLimitTier): this;
+    initialize<Params, Result, CustomSettings extends SettingsMap>(endpoints: AdapterEndpoint<Params, Result, CustomSettings>[], limits: AdapterRateLimitTier): this;
 }
 /**
  * RequestRateLimiters perform checks agains imminent outbound requests for any transport.
@@ -43,7 +44,7 @@ export interface BackgroundExecuteRateLimiter extends RateLimiter {
  * @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;
+export declare const consolidateTierLimits: (limits?: AdapterRateLimitTier) => number;
 /**
  * Validates rate limiting tiers specified for the adapter, and returns the one to use.
  *
@@ -51,4 +52,4 @@ export declare const consolidateTierLimits: (limits?: AdapterRateLimitTier | und
  * @param selectedTier - chosen API tier from settings, if present
  * @returns the specified API tier, or a default one if none are specified
  */
-export declare const getRateLimitingTier: (tiers?: Record<string, AdapterRateLimitTier> | undefined, selectedTier?: string | undefined) => AdapterRateLimitTier | undefined;
+export declare const getRateLimitingTier: (tiers?: Record<string, AdapterRateLimitTier>, selectedTier?: string) => AdapterRateLimitTier | undefined;

package/{rate-limiting → dist/src/rate-limiting}/request/simple-counting.d.ts

@@ -1,5 +1,6 @@
 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
@@ -15,6 +16,6 @@ export declare class SimpleCountingRateLimiter implements RateLimiter {
     requestsThisMinute: number;
     perSecondLimit: number;
     perMinuteLimit: number;
-    initialize(endpoints: AdapterEndpoint[], limits?: AdapterRateLimitTier): this;
+    initialize<Params, Result, CustomSettings extends SettingsMap>(endpoints: AdapterEndpoint<Params, Result, CustomSettings>[], limits?: AdapterRateLimitTier): this;
     isUnderLimits(): boolean;
 }

package/{test.js → dist/src/test.js}

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

package/{transports → dist/src/transports}/batch-warming.d.ts

@@ -2,9 +2,10 @@ import { AxiosRequestConfig, AxiosResponse } from 'axios';
 import { Cache } from '../cache';
 import { AdapterConfig, SettingsMap } from '../config';
 import { BackgroundExecuteRateLimiter } from '../rate-limiting';
-import { ExpiringSortedSet } from '../util';
+import { SubscriptionSet } from '../util';
 import { AdapterRequest, ProviderResult } from '../util/request';
-import { AdapterContext, AdapterDependencies, Transport } from './';
+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.
@@ -21,7 +22,7 @@ export declare class BatchWarmingTransport<AdapterParams, ProviderRequestBody, P
     private config;
     cache: Cache;
     rateLimiter: BackgroundExecuteRateLimiter;
-    expiringSortedSet: ExpiringSortedSet<AdapterParams>;
+    subscriptionSet: SubscriptionSet<AdapterParams>;
     WARMER_ACTIVE: boolean;
     constructor(config: {
         prepareRequest: (params: AdapterParams[], context: AdapterContext<CustomSettings>) => AxiosRequestConfig<ProviderRequestBody>;

package/{transports → dist/src/transports}/batch-warming.js

@@ -46,7 +46,6 @@ const logger = (0, util_1.makeLogger)('BatchWarmingTransport');
 class BatchWarmingTransport {
     constructor(config) {
         this.config = config;
-        this.expiringSortedSet = new util_1.ExpiringSortedSet(); // TODO: Move to dependencies, inject
         // Flag used to track whether the warmer has moved from having no entries to having some and vice versa
         // Used for recording the cache warmer active metrics accurately
         this.WARMER_ACTIVE = false;
@@ -54,17 +53,18 @@ class BatchWarmingTransport {
     async initialize(dependencies) {
         this.cache = dependencies.cache;
         this.rateLimiter = dependencies.backgroundExecuteRateLimiter;
+        this.subscriptionSet = dependencies.subscriptionSetFactory.buildSet();
     }
     async hasBeenSetUp(req) {
-        return !!this.expiringSortedSet.get(req.requestContext.cacheKey);
+        return !!(await this.subscriptionSet.get(req.requestContext.cacheKey));
     }
     async setup(req, config) {
         logger.debug(`Adding entry to batch warming set: [${req.requestContext.cacheKey}] = ${req.requestContext.data}`);
-        this.expiringSortedSet.add(req.requestContext.cacheKey, req.requestContext.data, config.WARMUP_SUBSCRIPTION_TTL);
+        await this.subscriptionSet.add(req.requestContext.cacheKey, req.requestContext.data, config.WARMUP_SUBSCRIPTION_TTL);
     }
     async backgroundExecute(context) {
         logger.debug('Starting background execute');
-        const entries = this.expiringSortedSet.getAll();
+        const entries = await this.subscriptionSet.getAll();
         if (!entries.length) {
             logger.debug('No entries in batch warming set, skipping');
             if (this.WARMER_ACTIVE) {

package/{transports → dist/src/transports}/index.d.ts

@@ -1,28 +1,11 @@
 import { FastifyReply } from 'fastify';
-import { AdapterEndpoint, InitializedAdapter } from '../adapter';
-import { Cache, CacheEntry } from '../cache';
-import { AdapterConfig, CustomSettingsType, SettingsMap } from '../config';
-import { BackgroundExecuteRateLimiter, RequestRateLimiter } from '../rate-limiting';
+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';
-/**
- * Dependencies that will be injected into the Adapter on startup
- */
-export interface AdapterDependencies {
-    cache: Cache;
-    requestRateLimiter: RequestRateLimiter;
-    backgroundExecuteRateLimiter: BackgroundExecuteRateLimiter;
-}
-/**
- * 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;
-    adapterConfig: AdapterConfig<CustomSettings>;
-}
 /**
  * Generic interface for a Transport.
  * A Transport defines the way in which an AdapterEndpoint will process incoming requests to
@@ -76,7 +59,7 @@ export interface Transport<Params, Result, CustomSettings extends SettingsMap> {
  * @param context - context for the Adapter
  * @returns a list of CacheEntries of AdapterResponses
  */
-export declare const buildCacheEntriesFromResults: <Params, Context extends AdapterContext<any>>(results: ProviderResult<Params>[], context: Context) => CacheEntry<AdapterResponse<null>>[];
+export declare const buildCacheEntriesFromResults: <Params, CustomSettings extends SettingsMap>(results: ProviderResult<Params>[], context: AdapterContext<CustomSettings>) => CacheEntry<AdapterResponse<null>>[];
 /**
  * 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.)
@@ -84,4 +67,4 @@ export declare const buildCacheEntriesFromResults: <Params, Context extends Adap
  * @param adapter - main adapter object, already initialized
  * @returns the transport handler middleware function
  */
-export declare const buildTransportHandler: (adapter: InitializedAdapter) => (req: AdapterRequest, reply: FastifyReply) => Promise<never>;
+export declare const buildTransportHandler: (adapter: Adapter) => (req: AdapterRequest, reply: FastifyReply) => Promise<never>;

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

@@ -43,9 +43,9 @@ const buildCacheEntriesFromResults = (results, context) => results.map((r) => {
             maxAge: Date.now() + context.adapterConfig.CACHE_MAX_AGE,
             meta: {
                 metrics: {
-                    feedId: (0, cache_1.calculateFeedId)(context.adapterEndpoint, r.params)
-                }
-            }
+                    feedId: (0, cache_1.calculateFeedId)(context, r.params),
+                },
+            },
         };
         cacheEntry.value = { ...cacheEntry.value, ...metrics };
     }

package/{transports → dist/src/transports}/metrics.d.ts

@@ -1,6 +1,7 @@
 import * as client from 'prom-client';
-import { AdapterContext } from '.';
-export declare const dataProviderMetricsLabel: (providerStatusCode?: number | undefined, method?: string) => {
+import { AdapterContext } from '../adapter';
+import { SettingsMap } from '../config';
+export declare const dataProviderMetricsLabel: (providerStatusCode?: number, method?: string) => {
     provider_status_code: number | undefined;
     method: string;
 };
@@ -13,7 +14,7 @@ export declare const messageSubsLabels: (feed_id: string, cache_key: string) =>
     feed_id: string;
     subscription_key: string;
 };
-export declare const recordWsMessageMetrics: <AdapterParams>(context: AdapterContext, subscribes: AdapterParams[], unsubscrices: AdapterParams[]) => void;
+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">;

package/{transports → dist/src/transports}/metrics.js

@@ -59,7 +59,7 @@ exports.messageSubsLabels = messageSubsLabels;
 // since avoiding storing extra info in expiring sorted set
 const recordWsMessageMetrics = (context, subscribes, unsubscrices) => {
     subscribes.forEach((param) => {
-        const feedId = (0, cache_1.calculateFeedId)(context.adapterEndpoint, param);
+        const feedId = (0, cache_1.calculateFeedId)(context, param);
         const cacheKey = (0, cache_1.calculateCacheKey)(context, param);
         // Record total number of ws messages sent
         exports.wsMessageTotal.labels((0, exports.messageSubsLabels)(feedId, cacheKey)).inc();
@@ -69,7 +69,7 @@ const recordWsMessageMetrics = (context, subscribes, unsubscrices) => {
         exports.wsSubscriptionActive.labels((0, exports.messageSubsLabels)(feedId, cacheKey)).inc();
     });
     unsubscrices.forEach((param) => {
-        const feedId = (0, cache_1.calculateFeedId)(context.adapterEndpoint, param);
+        const feedId = (0, cache_1.calculateFeedId)(context, param);
         const cacheKey = (0, cache_1.calculateCacheKey)(context, param);
         // Record total number of ws messages sent
         exports.wsMessageTotal.labels((0, exports.messageSubsLabels)(feedId, cacheKey)).inc();

package/{transports → dist/src/transports}/rest.d.ts

@@ -1,9 +1,10 @@
 import { AdapterRequest, AdapterResponse } from '../util/request';
-import { AdapterDependencies, Transport } from './';
+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.

package/{transports → dist/src/transports}/rest.js

@@ -101,7 +101,9 @@ class RestTransport {
         if (config.METRICS_ENABLED && config.EXPERIMENTAL_METRICS_ENABLED) {
             // TODO: Potentially create function to add all telemetry data
             parsedResponse.maxAge = Date.now() + config.CACHE_MAX_AGE;
-            parsedResponse.meta = { metrics: { feedId: req.requestContext.meta?.metrics?.feedId || 'N/A' } };
+            parsedResponse.meta = {
+                metrics: { feedId: req.requestContext.meta?.metrics?.feedId || 'N/A' },
+            };
         }
         logger.debug('Setting provider response in cache');
         await this.cache.set(req.requestContext.cacheKey, parsedResponse, config.CACHE_MAX_AGE);

package/{transports → dist/src/transports}/websocket.d.ts

@@ -1,11 +1,11 @@
 import WebSocket from 'ws';
+import { AdapterContext, AdapterDependencies } from '../adapter';
 import { Cache } from '../cache';
-import { SettingsMap } from '../config';
+import { AdapterConfig, SettingsMap } from '../config';
 import { BackgroundExecuteRateLimiter } from '../rate-limiting';
-import { ExpiringSortedSet } from '../util';
+import { SubscriptionSet } from '../util';
 import { AdapterRequest, ProviderResult } from '../util/request';
-import { AdapterContext, AdapterDependencies, Transport } from './';
-export declare const DEFAULT_WS_TTL = 10000;
+import { Transport } from './';
 declare type WebSocketClass = new (url: string, protocols?: string | string[] | undefined) => WebSocket;
 export declare class WebSocketClassProvider {
     static ctor: WebSocketClass;
@@ -55,7 +55,7 @@ export interface WebSocketTransportConfig<AdapterParams, ProviderDataMessage, Cu
     };
 }
 /**
- * Transport implementation that takes incoming requests, adds them to an [[ExpiringSortedSet]] and,
+ * 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
@@ -65,13 +65,13 @@ export declare class WebSocketTransport<AdapterParams, ProviderDataMessage, Cust
     private config;
     cache: Cache;
     rateLimiter: BackgroundExecuteRateLimiter;
-    expiringSortedSet: ExpiringSortedSet<AdapterParams>;
+    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>): Promise<void>;
+    setup(req: AdapterRequest<AdapterParams>, config: AdapterConfig<CustomSettings>): Promise<void>;
     serializeMessage(payload: unknown): string;
     deserializeMessage(data: WebSocket.Data): ProviderDataMessage;
     establishWsConnection(context: AdapterContext<CustomSettings>): Promise<unknown>;

package/{transports → dist/src/transports}/websocket.js

@@ -26,13 +26,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WebSocketTransport = exports.WebSocketClassProvider = exports.DEFAULT_WS_TTL = void 0;
+exports.WebSocketTransport = exports.WebSocketClassProvider = void 0;
 const ws_1 = __importDefault(require("ws"));
 const util_1 = require("../util");
 const _1 = require("./");
 const transportMetrics = __importStar(require("./metrics"));
-// TODO: Config
-exports.DEFAULT_WS_TTL = 10000;
 const logger = (0, util_1.makeLogger)('WebSocketTransport');
 class WebSocketClassProvider {
     static set(ctor) {
@@ -45,7 +43,7 @@ class WebSocketClassProvider {
 exports.WebSocketClassProvider = WebSocketClassProvider;
 WebSocketClassProvider.ctor = ws_1.default;
 /**
- * Transport implementation that takes incoming requests, adds them to an [[ExpiringSortedSet]] and,
+ * 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
@@ -55,21 +53,20 @@ class WebSocketTransport {
     constructor(config) {
         this.config = config;
         // The double sets serve to create a simple polling mechanism instead of needing a subscription
-        // This one would be either local, redis, etc
-        this.expiringSortedSet = new util_1.ExpiringSortedSet(); // TODO: Move to dependencies, inject
         // This one would not; this is always local state
         this.localSubscriptions = [];
     }
     async initialize(dependencies) {
         this.cache = dependencies.cache;
         this.rateLimiter = dependencies.backgroundExecuteRateLimiter;
+        this.subscriptionSet = dependencies.subscriptionSetFactory.buildSet();
     }
     async hasBeenSetUp(req) {
-        return !!this.expiringSortedSet.get(req.requestContext.cacheKey);
+        return !!(await this.subscriptionSet.get(req.requestContext.cacheKey));
     }
-    async setup(req) {
+    async setup(req, config) {
         logger.debug(`Adding entry to subscription set: [${req.requestContext.cacheKey}] = ${req.requestContext.data}`);
-        this.expiringSortedSet.add(req.requestContext.cacheKey, req.requestContext.data, exports.DEFAULT_WS_TTL);
+        await this.subscriptionSet.add(req.requestContext.cacheKey, req.requestContext.data, config.WS_SUBSCRIPTION_TTL);
     }
     // TODO: Maybe we don't do this, and leave the preparation on the adapter's side?
     // TODO: Maybe we store adapter params pre-prepared? That would be more efficient
@@ -85,7 +82,7 @@ class WebSocketTransport {
             const ctor = WebSocketClassProvider.get();
             this.wsConnection = new ctor(this.config.url);
             this.wsConnection.addEventListener('open', async (event) => {
-                logger.debug(`Opened websocket connection.`);
+                logger.debug(`Opened websocket connection. (event type ${event.type})`);
                 await this.config.handlers.open(this.wsConnection, context);
                 logger.debug('Successfully executed connection opened handler');
                 // Record active ws connections by incrementing count on open
@@ -121,7 +118,7 @@ class WebSocketTransport {
     // Unlike cache warming, this execute will manage subscriptions
     async backgroundExecute(context) {
         logger.debug('Starting background execute, getting subscriptions from sorted set');
-        const desiredSubs = this.expiringSortedSet.getAll();
+        const desiredSubs = await this.subscriptionSet.getAll();
         logger.debug('Generating delta (subscribes & unsubscribes)');
         // TODO: More efficient algorithm, this is really easy to read, but high(er) time complexity
         const subscribeParams = desiredSubs.filter((s) => !this.localSubscriptions.includes(s));

package/{util → dist/src/util}/index.d.ts

@@ -1,6 +1,6 @@
 export * from './request';
 export * from './logger';
-export * from './expiring-sorted-set';
+export * from './subscription-set/subscription-set';
 /**
  * Sleeps for the provided number of milliseconds
  * @param ms - The number of milliseconds to sleep for
@@ -9,3 +9,4 @@ export * from './expiring-sorted-set';
 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 → dist/src/util}/index.js

@@ -17,7 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isArray = exports.isObject = exports.sleep = void 0;
 __exportStar(require("./request"), exports);
 __exportStar(require("./logger"), exports);
-__exportStar(require("./expiring-sorted-set"), exports);
+__exportStar(require("./subscription-set/subscription-set"), exports);
 /**
  * Sleeps for the provided number of milliseconds
  * @param ms - The number of milliseconds to sleep for

package/{util → dist/src/util}/request.d.ts

@@ -1,5 +1,5 @@
 import { FastifyReply, FastifyRequest, HookHandlerDoneFunction } from 'fastify';
-import { InitializedAdapter } from '../adapter';
+import { Adapter } from '../adapter';
 import { AdapterError } from '../validation/error';
 declare module 'fastify' {
     interface FastifyRequest {
@@ -38,7 +38,9 @@ export interface AdapterMetricsMeta {
     feedId?: string;
     cacheHit?: boolean;
 }
-export declare type AdapterRequestData = Record<string, unknown>;
+export declare type AdapterRequestData = Record<string, unknown> & {
+    endpoint?: string;
+};
 export interface ProviderResult<Params> {
     params: Params;
     value: unknown;
@@ -52,4 +54,4 @@ export declare type AdapterResponse<T = unknown> = {
     providerStatusCode?: number;
 };
 export declare type Middleware = ((req: AdapterRequest, reply: FastifyReply, done: HookHandlerDoneFunction) => FastifyReply | void) | ((req: AdapterRequest, reply: FastifyReply) => Promise<FastifyReply | void>);
-export declare type AdapterMiddlewareBuilder = (adapter: InitializedAdapter) => Middleware;
+export declare type AdapterMiddlewareBuilder = (adapter: Adapter) => Middleware;

package/dist/src/util/subscription-set/expiring-sorted-set.d.ts

@@ -0,0 +1,22 @@
+import { SubscriptionSet } from './subscription-set';
+/**
+ * An object describing an entry in the expiring sorted set.
+ * @typeParam T - the type of the entry's value
+ */
+interface ExpiringSortedSetEntry<T> {
+    value: T;
+    expirationTimestamp: number;
+}
+/**
+ * This class implements a set of unique items, each of which has an expiration timestamp.
+ * On reads, items that have expired will be deleted from the set and not returned.
+ *
+ * @typeParam T - the type of the set entries' values
+ */
+export declare class ExpiringSortedSet<T> implements SubscriptionSet<T> {
+    map: Map<string, ExpiringSortedSetEntry<T>>;
+    add(key: string, value: T, ttl: number): void;
+    get(key: string): T | undefined;
+    getAll(): T[];
+}
+export {};

package/dist/src/util/subscription-set/expiring-sorted-set.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpiringSortedSet = void 0;
+/**
+ * This class implements a set of unique items, each of which has an expiration timestamp.
+ * On reads, items that have expired will be deleted from the set and not returned.
+ *
+ * @typeParam T - the type of the set entries' values
+ */
+class ExpiringSortedSet {
+    constructor() {
+        this.map = new Map();
+    }
+    add(key, value, ttl) {
+        this.map.set(key, {
+            value,
+            expirationTimestamp: Date.now() + ttl,
+        });
+    }
+    get(key) {
+        const entry = this.map.get(key);
+        if (!entry) {
+            return;
+        }
+        else if (entry.expirationTimestamp < Date.now()) {
+            return entry.value;
+        }
+        else {
+            this.map.delete(key);
+        }
+    }
+    getAll() {
+        const results = [];
+        const now = Date.now();
+        // Since we're iterating, might as well prune here
+        for (const [key, entry] of this.map.entries()) {
+            if (entry.expirationTimestamp < now) {
+                this.map.delete(key); // In theory, this shouldn't happen frequently for feeds
+            }
+            else {
+                results.push(entry.value);
+            }
+        }
+        return results;
+    }
+}
+exports.ExpiringSortedSet = ExpiringSortedSet;

package/dist/src/util/subscription-set/subscription-set.d.ts

@@ -0,0 +1,18 @@
+import { PromiseOrValue } from '..';
+import { AdapterConfig } from '../../config';
+/**
+ * Set to hold items to subscribe to from a provider (regardless of protocol)
+ */
+export interface SubscriptionSet<T> {
+    /** Add a new subscription to the set */
+    add(key: string, value: T, ttl: number): PromiseOrValue<void>;
+    /** Get a specific subscription from the set */
+    get(key: string): PromiseOrValue<T | undefined>;
+    /** Get all subscriptions from the set as a list */
+    getAll(): PromiseOrValue<T[]>;
+}
+export declare class SubscriptionSetFactory {
+    private cacheType;
+    constructor(config: AdapterConfig);
+    buildSet<T>(): SubscriptionSet<T>;
+}

package/dist/src/util/subscription-set/subscription-set.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubscriptionSetFactory = void 0;
+const expiring_sorted_set_1 = require("./expiring-sorted-set");
+class SubscriptionSetFactory {
+    constructor(config) {
+        this.cacheType = config.CACHE_TYPE;
+    }
+    buildSet() {
+        switch (this.cacheType) {
+            case 'local':
+                return new expiring_sorted_set_1.ExpiringSortedSet();
+            case 'redis':
+                // TODO: Implement redis set
+                return new expiring_sorted_set_1.ExpiringSortedSet();
+        }
+    }
+}
+exports.SubscriptionSetFactory = SubscriptionSetFactory;

package/dist/src/util/test-payload-loader.d.ts

@@ -0,0 +1,25 @@
+import { AdapterRequestData } from './request';
+/**
+ * The test payload read in from filesystem
+ */
+export interface Payload {
+    requests: Array<AdapterRequestData>;
+}
+/**
+ * Test payload with discriminated union so we can tell when we should just do
+ * a simple liveness check rather than a sample request
+ */
+declare type TestPayload = (Payload & {
+    isDefault: false;
+}) | {
+    isDefault: true;
+};
+/**
+ * Load in a JSON file containing a test payload for the current adapter,
+ * used in healthchecks to make sample requests
+ *
+ * @param fileName - name of file that contains the test payload data for the smoke endpoint
+ * @returns the parsed payload with individual requests
+ */
+export declare function loadTestPayload(fileName?: string): TestPayload;
+export {};