@chainlink/external-adapter-framework 0.0.14 → 0.0.15

package/transports/websocket.d.ts

@@ -1,81 +0,0 @@
-import WebSocket from 'ws';
-import { AdapterContext, AdapterDependencies } from '../adapter';
-import { Cache } from '../cache';
-import { SettingsMap } from '../config';
-import { BackgroundExecuteRateLimiter } from '../rate-limiting';
-import { SubscriptionSet } from '../util';
-import { AdapterRequest, ProviderResult } from '../util/request';
-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 {
-    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>): 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/transports/websocket.js

@@ -1,168 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __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;
-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) {
-        this.ctor = ctor;
-    }
-    static get() {
-        return this.ctor;
-    }
-}
-exports.WebSocketClassProvider = WebSocketClassProvider;
-WebSocketClassProvider.ctor = ws_1.default;
-/**
- * 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)
- */
-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 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 !!(await this.subscriptionSet.get(req.requestContext.cacheKey));
-    }
-    async setup(req) {
-        logger.debug(`Adding entry to subscription set: [${req.requestContext.cacheKey}] = ${req.requestContext.data}`);
-        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
-    // Assuming always JSON payloads for now, makes it all cleaner
-    serializeMessage(payload) {
-        return typeof payload === 'string' ? payload : JSON.stringify(payload);
-    }
-    deserializeMessage(data) {
-        return JSON.parse(data.toString());
-    }
-    establishWsConnection(context) {
-        return new Promise((resolve) => {
-            const ctor = WebSocketClassProvider.get();
-            this.wsConnection = new ctor(this.config.url);
-            this.wsConnection.addEventListener('open', async (event) => {
-                logger.debug(`Opened websocket connection.`);
-                await this.config.handlers.open(this.wsConnection, context);
-                logger.debug('Successfully executed connection opened handler');
-                // Record active ws connections by incrementing count on open
-                // Using URL in label since connection_key is removed from v3
-                transportMetrics.wsConnectionActive.inc();
-                resolve(true);
-            });
-            this.wsConnection.addEventListener('message', async (event) => {
-                // TODO: Assuming JSON always, maybe use BSON also?
-                const parsed = this.deserializeMessage(event.data);
-                logger.trace(`Got ws message: ${parsed}`);
-                const results = this.config.handlers.message(parsed, context);
-                if (Array.isArray(results)) {
-                    const responses = (0, _1.buildCacheEntriesFromResults)(results, context);
-                    logger.trace(`Writing ${responses.length} responses to cache`);
-                    await this.cache.setMany(responses, context.adapterConfig.CACHE_MAX_AGE);
-                }
-            });
-            this.wsConnection.addEventListener('error', async (event) => {
-                // Record connection error count
-                transportMetrics.wsConnectionErrors
-                    .labels(transportMetrics.connectionErrorLabels(event.message))
-                    .inc();
-            });
-            this.wsConnection.addEventListener('close', (event) => {
-                logger.debug(`Closed websocket connection. Code: ${event.code} ; reason: ${event.reason?.toString()}`);
-                // Record active ws connections by decrementing count on close
-                // Using URL in label since connection_key is removed from v3
-                transportMetrics.wsConnectionActive.dec();
-            });
-        });
-    }
-    // Unlike cache warming, this execute will manage subscriptions
-    async backgroundExecute(context) {
-        logger.debug('Starting background execute, getting subscriptions from sorted set');
-        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));
-        const subscribes = subscribeParams
-            .map(this.config.builders.subscribeMessage)
-            .map(this.serializeMessage);
-        const unsubscribeParams = this.localSubscriptions.filter((s) => !desiredSubs.includes(s));
-        const unsubscribes = unsubscribeParams
-            .map(this.config.builders.unsubscribeMessage)
-            .map(this.serializeMessage);
-        logger.debug(`${subscribes.length} new subscriptions; ${unsubscribes.length} to unsubscribe`);
-        if (subscribes.length) {
-            logger.trace(`Will subscribe to: ${subscribes}`);
-        }
-        if (unsubscribes.length) {
-            logger.trace(`Will unsubscribe to: ${unsubscribes}`);
-        }
-        // New subs && no connection -> connect -> add subs
-        // No new subs && no connection -> skip
-        // New subs && connection -> add subs
-        // No new subs && connection -> unsubs only
-        if (!subscribes.length && !this.wsConnection) {
-            logger.debug('No entries in subscription set and no established connection, skipping');
-            return this.rateLimiter.msUntilNextExecution(context.adapterEndpoint.name);
-        }
-        if (!this.wsConnection && subscribes.length) {
-            logger.debug('No established connection and new subscriptions available, connecting to WS');
-            await this.establishWsConnection(context);
-        }
-        // TODO: Close connection at some point?
-        logger.debug('Sending subs/unsubs if there are any');
-        const messages = unsubscribes.concat(subscribes);
-        for (const message of messages) {
-            logger.trace(`Sending message: ${JSON.stringify(message)}`);
-            this.wsConnection.send(message);
-        }
-        // Record WS message and subscription metrics
-        transportMetrics.recordWsMessageMetrics(context, subscribeParams, unsubscribeParams);
-        logger.debug('Setting local state to cache value');
-        this.localSubscriptions = desiredSubs;
-        logger.debug('Background execute complete');
-        return this.rateLimiter.msUntilNextExecution(context.adapterEndpoint.name);
-    }
-}
-exports.WebSocketTransport = WebSocketTransport;

package/util/expiring-sorted-set.d.ts

@@ -1,21 +0,0 @@
-/**
- * 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> {
-    map: Map<string, ExpiringSortedSetEntry<T>>;
-    add(key: string, value: T, ttl: number): void;
-    get(key: string): T | undefined;
-    getAll(): T[];
-}
-export {};

package/util/expiring-sorted-set.js

@@ -1,47 +0,0 @@
-"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/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/index.js

@@ -1,35 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isArray = exports.isObject = exports.sleep = void 0;
-__exportStar(require("./request"), exports);
-__exportStar(require("./logger"), exports);
-__exportStar(require("./subscription-set/subscription-set"), exports);
-/**
- * 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
- */
-const sleep = (ms) => {
-    return new Promise((resolve) => {
-        setTimeout(resolve, ms);
-    });
-};
-exports.sleep = sleep;
-const isObject = (o) => o !== null && typeof o === 'object' && Array.isArray(o) === false;
-exports.isObject = isObject;
-const isArray = (o) => o !== null && typeof o === 'object' && Array.isArray(o);
-exports.isArray = isArray;

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;

package/util/logger.js

@@ -1,62 +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.loggingContextMiddleware = exports.makeLogger = exports.asyncLocalStorage = void 0;
-const pino_1 = __importDefault(require("pino"));
-const config_1 = require("../config");
-const crypto_1 = require("crypto");
-const node_async_hooks_1 = require("node:async_hooks");
-exports.asyncLocalStorage = new node_async_hooks_1.AsyncLocalStorage();
-const debugTransport = {
-    target: 'pino-pretty',
-    options: {
-        levelFirst: true,
-        levelLabel: 'level',
-        ignore: 'layer,pid,hostname',
-        messageFormat: '[{correlationId}][{layer}] {msg}',
-        translateTime: 'yyyy-mm-dd HH:MM:ss.l',
-    },
-};
-// Base logger, shouldn't be used because we want layers to be specified
-const baseLogger = (0, pino_1.default)({
-    level: process.env['LOG_LEVEL']?.toLowerCase() || config_1.BaseSettings.LOG_LEVEL.default,
-    mixin() {
-        if (process.env['CORRELATION_ID_ENABLED'] === 'true') {
-            const store = exports.asyncLocalStorage.getStore();
-            if (store) {
-                return store;
-            }
-        }
-        return {};
-    },
-    transport: process.env['DEBUG'] === 'true' ? debugTransport : undefined,
-});
-/**
- * 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
- */
-const makeLogger = (layer) => baseLogger.child({ layer });
-exports.makeLogger = makeLogger;
-const loggingContextMiddleware = (req, res, done) => {
-    const correlationId = req.headers['x-correlation-id'] || (0, crypto_1.randomUUID)();
-    exports.asyncLocalStorage.run({ correlationId: correlationId }, () => {
-        done();
-    });
-};
-exports.loggingContextMiddleware = loggingContextMiddleware;

package/util/request.d.ts

@@ -1,57 +0,0 @@
-import { FastifyReply, FastifyRequest, HookHandlerDoneFunction } from 'fastify';
-import { InitializedAdapter } from '../adapter';
-import { AdapterError } from '../validation/error';
-declare module 'fastify' {
-    interface FastifyRequest {
-        requestContext: AdapterRequestContext;
-    }
-}
-export interface AdapterRequestBody<T = AdapterRequestData> {
-    endpoint?: string;
-    data: T;
-    id?: string;
-}
-export declare type AdapterRequestContext<T = AdapterRequestData> = {
-    id: string;
-    endpointName: string;
-    cacheKey: string;
-    data: T;
-    meta?: AdapterRequestMeta;
-};
-export declare type AdapterRouteGeneric<T = AdapterRequestData> = {
-    Body: AdapterRequestBody<T>;
-};
-export declare type AdapterRequest<T = AdapterRequestData> = FastifyRequest<AdapterRouteGeneric<T>> & {
-    requestContext: AdapterRequestContext<T>;
-};
-/**
- * Meta info that pertains to exposing metrics
- */
-export interface AdapterRequestMeta {
-    metrics?: AdapterMetricsMeta;
-    error?: AdapterError | Error;
-}
-/**
- * Meta info that pertains to exposing metrics
- */
-export interface AdapterMetricsMeta {
-    feedId?: string;
-    cacheHit?: boolean;
-}
-export declare type AdapterRequestData = Record<string, unknown> & {
-    endpoint?: string;
-};
-export interface ProviderResult<Params> {
-    params: Params;
-    value: unknown;
-}
-export declare type AdapterResponse<T = unknown> = {
-    statusCode: number;
-    data: T;
-    result: unknown;
-    maxAge?: number;
-    meta?: AdapterRequestMeta;
-    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;

package/util/request.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,22 +0,0 @@
-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/util/subscription-set/expiring-sorted-set.js

@@ -1,47 +0,0 @@
-"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/util/subscription-set/subscription-set.d.ts

@@ -1,18 +0,0 @@
-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/util/subscription-set/subscription-set.js

@@ -1,19 +0,0 @@
-"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/util/test-payload-loader.d.ts

@@ -1,25 +0,0 @@
-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 {};