@chainlink/external-adapter-framework 0.0.10 → 0.0.14

package/package/validation/validator.js

@@ -0,0 +1,303 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Validator = void 0;
+const error_1 = require("./error");
+const input_params_1 = require("./input-params");
+const util_1 = require("../util");
+const preset_tokens_json_1 = __importDefault(require("./preset-tokens.json"));
+// Don't want to get requester in just yet, only copying the static method 'errored'
+const requesterErrored = (jobRunID = '1', error = undefined, statusCode = 500, feedID = undefined) => {
+    if (error instanceof error_1.AdapterError) {
+        error.jobRunID = jobRunID;
+        if (feedID) {
+            error.feedID = feedID;
+        }
+        return error.toJSONResponse();
+    }
+    if (error instanceof Error) {
+        return new error_1.AdapterError({
+            jobRunID,
+            statusCode,
+            message: error.message,
+            cause: error,
+            feedID,
+        }).toJSONResponse();
+    }
+    return new error_1.AdapterError({ jobRunID, statusCode, message: error, feedID }).toJSONResponse();
+};
+class Validator {
+    constructor(input = { id: '1', data: {} }, inputConfigs = {}, inputOptions = {}, validatorOptions = {}) {
+        // OverrideSymbol = (adapter: string, symbol?: string | string[]): string | string[] => {
+        //   Const defaultSymbol = symbol || this.validated.data.base
+        //   If (!defaultSymbol) this.throwInvalid(`Required parameter not supplied: base`)
+        //   // TODO: Will never be reached, because the presetSymbols are used as default overrides
+        //   If (!this.validated.overrides) return defaultSymbol
+        //   If (!Array.isArray(defaultSymbol))
+        //     Return (
+        //       This.validated.overrides.get(adapter.toLowerCase())?.get(defaultSymbol.toLowerCase()) ||
+        //       DefaultSymbol
+        //     )
+        //   Const multiple: string[] = []
+        //   For (const sym of defaultSymbol) {
+        //     Const overrided = this.validated.overrides.get(adapter.toLowerCase())?.get(sym.toLowerCase())
+        //     If (!overrided) multiple.push(sym)
+        //     Else multiple.push(overrided)
+        //   }
+        //   Return multiple
+        // }
+        // OverrideToken = (symbol: string, network = 'ethereum'): string | undefined => {
+        //   Return this.validated.tokenOverrides?.get(network.toLowerCase())?.get(symbol.toLowerCase())
+        // }
+        // OverrideIncludes = (from: string, to: string): IncludePair | undefined => {
+        //   // Search through `presetIncludes` to find matching override for adapter and to/from pairing.
+        //   Const pairs = (
+        //     This.validated.includes?.filter(
+        //       (val: string | Includes) => typeof val !== 'string',
+        //     ) as Includes[]
+        //   ).filter(
+        //     (pair) =>
+        //       Pair.from.toLowerCase() === from.toLowerCase() &&
+        //       Pair.to.toLowerCase() === to.toLowerCase(),
+        //   )
+        //   If (!pairs || !pairs[0] || !pairs[0].includes || !pairs[0].includes[0]) {
+        //     Return
+        //   }
+        //   Return pairs[0].includes[0]
+        // }
+        // OverrideReverseLookup = (adapter: string, type: OverrideType, symbol: string): string => {
+        //   Const overrides: Map<string, string> | undefined = this.validated?.[type]?.get(
+        //     Adapter.toLowerCase(),
+        //   )
+        //   If (!overrides) return symbol
+        //   Let originalSymbol: string | undefined
+        //   Overrides.forEach((overridden, original) => {
+        //     If (overridden.toLowerCase() === symbol.toLowerCase()) originalSymbol = original
+        //   })
+        //   Return originalSymbol || symbol
+        // }
+        this.formatOverride = (param) => {
+            const _throwInvalid = () => this.throwInvalid(`Parameter supplied with wrong format: "override"`);
+            if (!(0, util_1.isObject)(param)) {
+                _throwInvalid();
+            }
+            const _isValid = Object.values(param).every(util_1.isObject);
+            if (!_isValid) {
+                _throwInvalid();
+            }
+            const _keyToLowerCase = (entry) => {
+                return [entry[0].toLowerCase(), entry[1]];
+            };
+            return new Map(Object.entries(param)
+                .map(_keyToLowerCase)
+                .map(([key, value]) => [key, new Map(Object.entries(value).map(_keyToLowerCase))]));
+        };
+        this.formatIncludeOverrides = (param) => {
+            const _throwInvalid = () => this.throwInvalid(`Parameter supplied with wrong format: "includes"`);
+            if (!(0, util_1.isArray)(param)) {
+                _throwInvalid();
+            }
+            const _isValid = Object.values(param).every((val) => (0, util_1.isObject)(val) || typeof val === 'string');
+            if (!_isValid) {
+                _throwInvalid();
+            }
+            return param;
+        };
+        this.throwInvalid = (message) => {
+            throw new error_1.AdapterError({ jobRunID: this.validated.id, statusCode: 400, message });
+        };
+        this.input = { ...input };
+        if (!this.input.id) {
+            this.input.id = '1';
+        } // TODO Please remove these once "no any" strict typing is enabled
+        if (!this.input.data) {
+            this.input.data = {};
+        }
+        this.inputConfigs = { ...input_params_1.baseInputParameters, ...inputConfigs };
+        this.inputOptions = { ...inputOptions };
+        this.validatorOptions = {
+            shouldThrowError: true,
+            includes: [],
+            overrides: {},
+            ...validatorOptions,
+        };
+        this.validated = { id: this.input.id, data: {} };
+        this.validateInput();
+        this.validateOverrides('overrides', this.validatorOptions.overrides);
+        this.validateOverrides('tokenOverrides', preset_tokens_json_1.default);
+        this.validateIncludeOverrides();
+        this.checkDuplicateInputParams(inputConfigs);
+    }
+    validateInput() {
+        try {
+            for (const key in this.inputConfigs) {
+                this.validateObjectParam(key, this.validatorOptions.shouldThrowError);
+            }
+        }
+        catch (e) {
+            this.parseError(e);
+        }
+    }
+    validateOverrides(path, preset) {
+        try {
+            if (!this.input.data?.[path]) {
+                this.validated[path] = this.formatOverride(preset);
+                return;
+            }
+            this.validated[path] = this.formatOverride({ ...preset, ...this.input.data[path] });
+        }
+        catch (e) {
+            this.parseError(e);
+        }
+    }
+    checkDuplicateInputParams(inputConfig) {
+        let aliases = [];
+        for (const key in inputConfig) {
+            const param = inputConfig[key];
+            if (Array.isArray(param)) {
+                aliases = aliases.concat(param);
+            }
+            else if (typeof inputConfig === 'boolean') {
+                return;
+            }
+            else {
+                aliases.push(key);
+                if (typeof param === 'object' && 'aliases' in param && Array.isArray(param.aliases)) {
+                    aliases = aliases.concat(param.aliases);
+                }
+            }
+        }
+        if (aliases.length !== new Set(aliases).size) {
+            this.throwInvalid('Duplicate Input Aliases');
+        }
+    }
+    validateIncludeOverrides() {
+        try {
+            this.validated.includes = this.formatIncludeOverrides([
+                ...(Array.isArray(this.input.data?.includes) ? this.input.data.includes : []),
+                ...(this.validatorOptions.includes || []),
+            ]);
+        }
+        catch (e) {
+            this.parseError(e);
+        }
+    }
+    parseError(error) {
+        if (!(error instanceof Error)) {
+            return;
+        }
+        const message = 'Error validating input.';
+        if (error instanceof error_1.AdapterError) {
+            this.error = error;
+        }
+        else {
+            this.error = new error_1.AdapterError({
+                jobRunID: this.validated.id,
+                statusCode: 400,
+                message,
+                cause: error,
+            });
+        }
+        this.errored = requesterErrored(this.validated.id, this.error);
+        if (this.validatorOptions.shouldThrowError) {
+            throw this.error;
+        }
+    }
+    validateObjectParam(key, shouldThrowError = true) {
+        const inputConfig = this.inputConfigs[key];
+        const usedKey = this.getUsedKey(key, inputConfig.aliases ?? []);
+        const param = usedKey
+            ? this.input.data[usedKey] ?? inputConfig.default
+            : inputConfig.default;
+        if (shouldThrowError) {
+            const paramIsDefined = !(param === undefined || param === null || param === '');
+            if (inputConfig.required && !paramIsDefined) {
+                this.throwInvalid(`Required parameter ${key} must be non-null and non-empty`);
+            }
+            if (paramIsDefined) {
+                if (inputConfig.type) {
+                    const primitiveTypes = ['boolean', 'number', 'bigint', 'string'];
+                    if (![...primitiveTypes, 'array', 'object'].includes(inputConfig.type)) {
+                        this.throwInvalid(`${key} parameter has unrecognized type ${inputConfig.type}`);
+                    }
+                    if (primitiveTypes.includes(inputConfig.type) && typeof param !== inputConfig.type) {
+                        this.throwInvalid(`${key} parameter must be of type ${inputConfig.type}`);
+                    }
+                    if (inputConfig.type === 'array' && (!Array.isArray(param) || param.length === 0)) {
+                        this.throwInvalid(`${key} parameter must be a non-empty array`);
+                    }
+                    if (inputConfig.type === 'object' &&
+                        (!param ||
+                            Array.isArray(param) ||
+                            typeof param !== inputConfig.type ||
+                            Object.keys(param).length === 0)) {
+                        this.throwInvalid(`${key} parameter must be an object with at least one property`);
+                    }
+                }
+                // If (inputConfig.options) {
+                //   Const tolcase = (o: any) => (typeof o === 'string' ? o.toLowerCase() : o)
+                //   Const formattedOptions = inputConfig.options.map(tolcase)
+                //   Const formattedParam = tolcase(param)
+                //   If (!formattedOptions.includes(formattedParam))
+                //     This.throwInvalid(
+                //       `${key} parameter '${formattedParam}' is not in the set of available options: ${formattedOptions.join(
+                //         ',',
+                //       )}`,
+                //     )
+                // }
+                // For (const dependency of inputConfig.dependsOn ?? []) {
+                //   Const usedDependencyKey = this.getUsedKey(
+                //     Dependency,
+                //     (this.inputConfigs[dependency] as InputParameter).aliases ?? [],
+                //   )
+                //   If (!usedDependencyKey) this.throwInvalid(`${key} dependency ${dependency} not supplied`)
+                // }
+                // For (const exclusive of inputConfig.exclusive ?? []) {
+                //   Const usedExclusiveKey = this.getUsedKey(
+                //     Exclusive,
+                //     (this.inputConfigs[exclusive] as InputParameter).aliases ?? [],
+                //   )
+                //   If (usedExclusiveKey)
+                //     This.throwInvalid(`${key} cannot be supplied concurrently with ${exclusive}`)
+                // }
+            }
+        }
+        this.validated.data[key] = param;
+    }
+    validateOptionalParam(param, key, options) {
+        if (param && options) {
+            if (!Array.isArray(options)) {
+                this.throwInvalid(`Parameter options for ${key} must be of an Array type`);
+            }
+            if (!options.includes(param)) {
+                this.throwInvalid(`${param} is not a supported ${key} option. Must be one of ${options}`);
+            }
+        }
+        this.validated.data[key] = param;
+    }
+    validateRequiredParam(param, key, options) {
+        if (typeof param === 'undefined' || param === '') {
+            this.throwInvalid(`Required parameter not supplied: ${key}`);
+        }
+        if (options) {
+            if (!Array.isArray(options)) {
+                this.throwInvalid(`Parameter options for ${key} must be of an Array type`);
+            }
+            if (!options.includes(param)) {
+                this.throwInvalid(`${param} is not a supported ${key} option. Must be one of ${options.join(' || ')}`);
+            }
+        }
+        this.validated.data[key] = param;
+    }
+    getUsedKey(key, keyArray) {
+        const comparisonArray = [...keyArray];
+        if (!comparisonArray.includes(key)) {
+            comparisonArray.push(key);
+        }
+        const inputParamKeys = Object.keys(this.input.data);
+        return inputParamKeys.find((k) => comparisonArray.includes(k));
+    }
+}
+exports.Validator = Validator;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chainlink/external-adapter-framework",
-  "version": "0.0.10",
+  "version": "0.0.14",
   "main": "dist/index.js",
   "license": "MIT",
   "dependencies": {
@@ -19,7 +19,8 @@
     "test": "LOG_LEVEL=error EA_PORT=0 c8 ava",
     "test-debug": "LOG_LEVEL=trace DEBUG=true EA_PORT=0 c8 ava --verbose",
     "build": "tsc",
-    "lint": "eslint ./src"
+    "lint": "eslint ./src && prettier --check ./src/**/*.ts",
+    "dev": "NODE_ENV=develop tsnd --respawn --transpile-only --project tsconfig.json './src/test.ts'"
   },
   "devDependencies": {
     "@sinonjs/fake-timers": "^9.1.2",
@@ -37,7 +38,8 @@
     "nock": "^13.2.4",
     "pino-pretty": "^7.6.0",
     "prettier": "^2.6.1",
-    "typedoc": "^0.22.15"
+    "typedoc": "^0.22.15",
+    "ts-node-dev": "2.0.0"
   },
   "prettier": {
     "semi": false,

package/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/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/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/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/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, InitializedAdapter } 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.)

package/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/metrics.d.ts

@@ -1,5 +1,5 @@
 import * as client from 'prom-client';
-import { AdapterContext } from '.';
+import { AdapterContext } from '../adapter';
 export declare const dataProviderMetricsLabel: (providerStatusCode?: number, method?: string) => {
     provider_status_code: number | undefined;
     method: string;

package/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/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/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/websocket.d.ts

@@ -1,10 +1,11 @@
 import WebSocket from 'ws';
+import { AdapterContext, AdapterDependencies } from '../adapter';
 import { Cache } from '../cache';
 import { 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 './';
 export declare const DEFAULT_WS_TTL = 10000;
 declare type WebSocketClass = new (url: string, protocols?: string | string[] | undefined) => WebSocket;
 export declare class WebSocketClassProvider {
@@ -55,7 +56,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,7 +66,7 @@ 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>);

package/transports/websocket.js

@@ -45,7 +45,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 +55,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) {
         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, exports.DEFAULT_WS_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
@@ -121,7 +120,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/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/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/request.d.ts

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

package/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 {};