@chainlink/external-adapter-framework 0.0.14 → 0.0.16

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

@@ -0,0 +1,41 @@
+"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/{package/examples/coingecko → examples/coingecko-old}/batch-warming.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.batchEndpoint = void 0;
+const adapter_1 = require("../../adapter");
 const batch_warming_1 = require("../../transports/batch-warming");
 const DEFAULT_URL = 'https://pro-api.coingecko.com/api/v3';
 const inputParameters = {
@@ -32,7 +33,7 @@ const batchEndpointTransport = new batch_warming_1.BatchWarmingTransport({
             },
         };
     },
-    parseResponse: (res) => {
+    parseResponse: (params, res) => {
         const entries = [];
         for (const [base, entry] of Object.entries(res.data)) {
             for (const [quote, price] of Object.entries(entry)) {
@@ -45,8 +46,8 @@ const batchEndpointTransport = new batch_warming_1.BatchWarmingTransport({
         return entries;
     },
 });
-exports.batchEndpoint = {
+exports.batchEndpoint = new adapter_1.AdapterEndpoint({
     name: 'batch',
     transport: batchEndpointTransport,
     inputParameters,
-};
+});

package/examples/{coingecko → coingecko-old}/index.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.adapter = void 0;
+const adapter_1 = require("../../adapter");
 const batch_warming_1 = require("./batch-warming");
 const rest_1 = require("./rest");
-exports.adapter = {
+exports.adapter = new adapter_1.Adapter({
     name: 'coingecko',
     defaultEndpoint: 'batch',
     endpoints: [rest_1.restEndpoint, batch_warming_1.batchEndpoint],
-};
+});

package/{package/examples/coingecko → examples/coingecko-old}/rest.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.restEndpoint = void 0;
+const adapter_1 = require("../../adapter");
 const transports_1 = require("../../transports");
 const DEFAULT_URL = 'https://api.coingecko.com/api/v3';
 const inputParameters = {
@@ -42,9 +43,9 @@ const restEndpointTransport = new transports_1.RestTransport({
         coalescing: true,
     },
 });
-exports.restEndpoint = {
+exports.restEndpoint = new adapter_1.AdapterEndpoint({
     name: 'rest',
     aliases: ['qwe'],
     transport: restEndpointTransport,
     inputParameters,
-};
+});

package/examples/ncfx/index.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.adapter = void 0;
+const adapter_1 = require("../../adapter");
 const config_1 = require("./config");
 const websocket_1 = require("./websocket");
-exports.adapter = {
+exports.adapter = new adapter_1.Adapter({
     name: 'ncfx',
     endpoints: [websocket_1.webSocketEndpoint],
     customSettings: config_1.customSettings,
-};
+});

package/examples/ncfx/websocket.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.webSocketEndpoint = exports.websocketTransport = exports.inputParameters = void 0;
+const adapter_1 = require("../../adapter");
 const websocket_1 = require("../../transports/websocket");
 const util_1 = require("../../util");
 exports.inputParameters = {
@@ -65,8 +66,8 @@ exports.websocketTransport = new websocket_1.WebSocketTransport({
         }),
     },
 });
-exports.webSocketEndpoint = {
+exports.webSocketEndpoint = new adapter_1.AdapterEndpoint({
     name: 'websocket',
     transport: exports.websocketTransport,
     inputParameters: exports.inputParameters,
-};
+});

package/index.js

@@ -6,10 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.expose = void 0;
 const fastify_1 = __importDefault(require("fastify"));
 const path_1 = require("path");
-const adapter_1 = require("./adapter");
 const background_executor_1 = require("./background-executor");
 const cache_1 = require("./cache");
-const config_1 = require("./config");
 const metrics_1 = require("./metrics");
 const transports_1 = require("./transports");
 const util_1 = require("./util");
@@ -26,22 +24,18 @@ const VERSION = process.env['npm_package_version'];
  * @returns a Promise that resolves to the http.Server listening for connections
  */
 const expose = async (adapter, dependencies) => {
-    const config = (0, config_1.buildAdapterConfig)({
-        overrides: adapter.envDefaultOverrides,
-        customSettings: adapter.customSettings,
-    });
     // Initialize adapter (create dependencies, inject them, build endpoint map, etc.)
-    const initializedAdapter = await (0, adapter_1.initializeAdapter)(adapter, config, dependencies);
+    await adapter.initialize(dependencies);
     let server = undefined;
-    if (config.METRICS_ENABLED && config.EXPERIMENTAL_METRICS_ENABLED) {
-        (0, metrics_1.setupMetricsServer)(adapter.name, config);
+    if (adapter.config.METRICS_ENABLED && adapter.config.EXPERIMENTAL_METRICS_ENABLED) {
+        (0, metrics_1.setupMetricsServer)(adapter.name, adapter.config);
     }
-    if (config.EA_MODE === 'reader' || config.EA_MODE === 'reader-writer') {
+    if (adapter.config.EA_MODE === 'reader' || adapter.config.EA_MODE === 'reader-writer') {
         // Main REST API server to handle incoming requests
-        const app = await buildRestApi(config, initializedAdapter);
+        const app = await buildRestApi(adapter);
         // Start listening for incoming requests
         try {
-            await app.listen(config.EA_PORT, config.EA_HOST);
+            await app.listen(adapter.config.EA_PORT, adapter.config.EA_HOST);
         }
         catch (err) {
             logger.fatal(`There was an error when starting the EA server: ${err}`);
@@ -53,10 +47,10 @@ const expose = async (adapter, dependencies) => {
     else {
         logger.info('REST API is disabled; this instance will not process incoming requests.');
     }
-    if (config.EA_MODE === 'writer' || config.EA_MODE === 'reader-writer') {
+    if (adapter.config.EA_MODE === 'writer' || adapter.config.EA_MODE === 'reader-writer') {
         // Start background loop that will take care of calling any async Transports
         logger.info('Starting background execution loop');
-        (0, background_executor_1.callBackgroundExecutes)(initializedAdapter, server);
+        (0, background_executor_1.callBackgroundExecutes)(adapter, server);
     }
     else {
         logger.info('Background executor is disabled; this instance will not perform async background executes.');
@@ -64,33 +58,33 @@ const expose = async (adapter, dependencies) => {
     return server;
 };
 exports.expose = expose;
-async function buildRestApi(config, initializedAdapter) {
+async function buildRestApi(adapter) {
     const app = (0, fastify_1.default)();
     // Add healthcheck endpoint before middlewares to bypass them
-    app.get((0, path_1.join)(config.BASE_URL, 'health'), (req, res) => {
+    app.get((0, path_1.join)(adapter.config.BASE_URL, 'health'), (req, res) => {
         res.status(200).send({ message: 'OK', version: VERSION });
     });
     // Use global error handling
     app.setErrorHandler(validation_1.errorCatchingMiddleware);
-    const transportHandler = await (0, transports_1.buildTransportHandler)(initializedAdapter);
+    const transportHandler = await (0, transports_1.buildTransportHandler)(adapter);
     app.register(async (router) => {
         // Set up "middlewares" (hooks in fastify)
-        router.addHook('preHandler', (0, validation_1.validatorMiddleware)(initializedAdapter));
-        router.addHook('preHandler', (0, cache_1.buildCacheMiddleware)(initializedAdapter));
-        if (config['CORRELATION_ID_ENABLED']) {
+        router.addHook('preHandler', (0, validation_1.validatorMiddleware)(adapter));
+        router.addHook('preHandler', (0, cache_1.buildCacheMiddleware)(adapter));
+        if (adapter.config['CORRELATION_ID_ENABLED']) {
             router.addHook('onRequest', util_1.loggingContextMiddleware);
         }
         router.route({
-            url: config.BASE_URL,
+            url: adapter.config.BASE_URL,
             method: 'POST',
             handler: transportHandler,
         });
-        if (config.METRICS_ENABLED && config.EXPERIMENTAL_METRICS_ENABLED) {
+        if (adapter.config.METRICS_ENABLED && adapter.config.EXPERIMENTAL_METRICS_ENABLED) {
             router.addHook('onResponse', metrics_1.buildMetricsMiddleware);
         }
     });
     // Add smoke endpoint after middleware which are needed for tests
-    buildSmokeEndpoint(app, config);
+    buildSmokeEndpoint(app, adapter.config);
     return app;
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chainlink/external-adapter-framework",
-  "version": "0.0.14",
+  "version": "0.0.16",
   "main": "dist/index.js",
   "license": "MIT",
   "dependencies": {
@@ -38,8 +38,8 @@
     "nock": "^13.2.4",
     "pino-pretty": "^7.6.0",
     "prettier": "^2.6.1",
-    "typedoc": "^0.22.15",
-    "ts-node-dev": "2.0.0"
+    "ts-node-dev": "2.0.0",
+    "typedoc": "^0.22.15"
   },
   "prettier": {
     "semi": false,
@@ -66,6 +66,7 @@
     "workerThreads": false,
     "environmentVariables": {
       "METRICS_ENABLED": "false"
-    }
+    },
+    "timeout": "20s"
   }
 }

package/rate-limiting/index.js

@@ -34,11 +34,16 @@ exports.consolidateTierLimits = consolidateTierLimits;
 /**
  * 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
- * @param selectedTier - chosen API tier from settings, if present
  * @returns the specified API tier, or a default one if none are specified
  */
-const getRateLimitingTier = (tiers, selectedTier) => {
+const getRateLimitingTier = (config, tiers) => {
+    if (config.RATE_LIMIT_CAPACITY ||
+        config.RATE_LIMIT_CAPACITY_MINUTE ||
+        config.RATE_LIMIT_CAPACITY_SECOND) {
+        return buildRateLimitTiersFromConfig(config);
+    }
     if (!tiers) {
         return;
     }
@@ -47,6 +52,7 @@ const getRateLimitingTier = (tiers, selectedTier) => {
         throw new Error(`The tiers object is defined, but has no entries`);
     }
     // Check that the tier set in the AdapterConfig is a valid one
+    const selectedTier = config.RATE_LIMIT_API_TIER;
     if (selectedTier && !tiers[selectedTier]) {
         const validTiersString = Object.keys(tiers)
             .map((t) => `"${t}"`)
@@ -61,3 +67,18 @@ const getRateLimitingTier = (tiers, selectedTier) => {
     return tiers[selectedTier];
 };
 exports.getRateLimitingTier = getRateLimitingTier;
+// Creates adapter rate limit tier using the configs specified in env vars
+const buildRateLimitTiersFromConfig = (config) => {
+    const rateLimit1s = config.RATE_LIMIT_CAPACITY_SECOND;
+    let rateLimit1m;
+    if (config.RATE_LIMIT_CAPACITY_MINUTE) {
+        rateLimit1m = config.RATE_LIMIT_CAPACITY_MINUTE;
+    }
+    else if (config.RATE_LIMIT_CAPACITY) {
+        rateLimit1m = config.RATE_LIMIT_CAPACITY;
+    }
+    return {
+        rateLimit1s,
+        rateLimit1m,
+    };
+};

package/transports/batch-warming.js

@@ -81,7 +81,7 @@ class BatchWarmingTransport {
         }
         const request = this.config.prepareRequest(entries, context);
         logger.trace('Sending request to data provider...');
-        const providerResponse = await (0, util_2.axiosRequest)(request);
+        const providerResponse = await (0, util_2.axiosRequest)(request, context.adapterConfig);
         logger.debug(`Got response from provider, parsing (raw body: ${providerResponse.data})`);
         const results = this.config.parseResponse(providerResponse, context);
         const adapterResponses = (0, _1.buildCacheEntriesFromResults)(results, context);

package/transports/rest.js

@@ -45,10 +45,14 @@ class RestTransport {
     constructor(config) {
         this.config = config;
     }
-    async initialize(dependencies) {
+    async initialize(dependencies, config) {
         this.inFlightPrefix = `${IN_FLIGHT_PREFIX}-`;
         this.cache = dependencies.cache;
         this.rateLimiter = dependencies.requestRateLimiter;
+        // Allow enabling/disabling request coalescing through env var
+        if (config.REQUEST_COALESCING_ENABLED !== undefined) {
+            this.config.options.coalescing = config.REQUEST_COALESCING_ENABLED;
+        }
     }
     async hasBeenSetUp(req) {
         if (!this.config.options.coalescing) {
@@ -95,9 +99,12 @@ class RestTransport {
             msBetweenRetries: config.REST_TRANSPORT_MS_BETWEEN_RATE_LIMIT_RETRIES,
         });
         logger.trace('Sending request to data provider...');
-        const providerResponse = await (0, util_2.axiosRequest)(request);
+        const providerResponse = await (0, util_2.axiosRequest)(request, config);
         logger.debug(`Got response from provider, parsing (raw body: ${providerResponse.data})`); // TODO: Sensitive data?
         const parsedResponse = await this.config.parseResponse(req, providerResponse, config);
+        if (config.API_VERBOSE) {
+            parsedResponse.data = providerResponse.data;
+        }
         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;

package/transports/util.js

@@ -36,10 +36,11 @@ const transportMetrics = __importStar(require("./metrics"));
  * @param request - axios request config
  * @returns axios response for the request
  */
-async function axiosRequest(request) {
+async function axiosRequest(request, config) {
     const responseTimer = transportMetrics.dataProviderRequestDurationSeconds.startTimer();
     let providerResponse;
     try {
+        request.timeout = config.API_TIMEOUT;
         providerResponse = await axios_1.default.request(request);
     }
     catch (e) {

package/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) {
@@ -66,9 +64,9 @@ class WebSocketTransport {
     async hasBeenSetUp(req) {
         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}`);
-        await this.subscriptionSet.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
@@ -84,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

package/util/recordRequests.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recordRequests = void 0;
+const fs_1 = __importDefault(require("fs"));
+const recordRequests = (requestConfig, providerResponse) => {
+    let recordedRequests = {};
+    try {
+        recordedRequests = JSON.parse(fs_1.default.readFileSync('capturedRequests.json').toString());
+    }
+    catch { } // eslint-disable-line no-empty
+    let baseUrl = requestConfig.baseURL;
+    baseUrl =
+        nthIndexOf(baseUrl, '/', 3) === -1 ? baseUrl : baseUrl.slice(0, nthIndexOf(baseUrl, '/', 3));
+    const recordedRequest = {
+        method: requestConfig.method,
+        path: providerResponse.request.path,
+        data: requestConfig.data,
+        response: providerResponse.data,
+        statusCode: providerResponse.status,
+    };
+    if (!recordedRequests[baseUrl]) {
+        recordedRequests[baseUrl] = [recordedRequest];
+    }
+    else if (recordedRequests[baseUrl].every((r) => {
+        return r.path !== recordedRequest.path;
+    })) {
+        recordedRequests[baseUrl].push(recordedRequest);
+    }
+    fs_1.default.writeFileSync('capturedRequests.json', JSON.stringify(recordedRequests));
+};
+exports.recordRequests = recordRequests;
+const nthIndexOf = (input, match, n) => {
+    let i = -1;
+    let n_ = n;
+    while (n_-- && i++ < input.length) {
+        i = input.indexOf(match, i);
+        if (i < 0) {
+            break;
+        }
+    }
+    return i;
+};

package/adapter.d.ts

@@ -1,107 +0,0 @@
-import { Cache } from './cache';
-import { AdapterConfig, BaseAdapterConfig, CustomSettingsType, SettingsMap } from './config';
-import { AdapterRateLimitTier, BackgroundExecuteRateLimiter, RequestRateLimiter } from './rate-limiting';
-import { Transport } from './transports';
-import { SubscriptionSetFactory } from './util';
-import { InputParameters } from './validation/input-params';
-/**
- * Dependencies that will be injected into the Adapter on startup
- */
-export interface AdapterDependencies {
-    cache: Cache;
-    requestRateLimiter: RequestRateLimiter;
-    backgroundExecuteRateLimiter: BackgroundExecuteRateLimiter;
-    subscriptionSetFactory: SubscriptionSetFactory;
-}
-/**
- * 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>;
-}
-/**
- * Structure to describe rate limits specs for the Adapter
- */
-interface AdapterRateLimitingConfig {
-    /** Adapter rate limits, gotten from the specific tier requested */
-    tiers: Record<string, AdapterRateLimitTier>;
-}
-/**
- * Main structure of an External Adapter
- */
-export interface Adapter {
-    /** Name of the adapter */
-    name: string;
-    /** If present, the string that will be used for requests with no specified endpoint */
-    defaultEndpoint?: string;
-    /** List of [[AdapterEndpoint]]s in the adapter */
-    endpoints: AdapterEndpoint[];
-    /** Map of overrides to the default config values for an Adapter */
-    envDefaultOverrides?: Partial<BaseAdapterConfig>;
-    /** List of custom env vars for this particular adapter (e.g. RPC_URL) */
-    customSettings?: SettingsMap;
-    /** Configuration relevant to outbound (EA --\> DP) communication rate limiting */
-    rateLimiting?: AdapterRateLimitingConfig;
-    /** Overrides for converting the 'base' parameter that are hardcoded into the adapter. */
-    overrides?: Record<string, string>;
-}
-/**
- * Structure to describe rate limits specs for a specific adapter endpoint
- */
-export interface EndpointRateLimitingConfig {
-    /**
-     * How much of the total limit for the adapter will be assigned to this specific endpoint.
-     * Should be a non-zero positive number up to 100.
-     * Endpoints in the same adapter without a specific allocation will divide the remaining limits equally.
-     */
-    allocationPercentage: number;
-}
-/**
- * Structure to describe a specific endpoint in an [[Adapter]]
- */
-export interface AdapterEndpoint {
-    /** Name that will be used to match input params to this endpoint (case insensitive) */
-    name: string;
-    /** List of alternative endpoint names that will resolve to this same transport (case insensitive) */
-    aliases?: string[];
-    /** Transport that will be used to handle data processing and communication for this endpoint */
-    transport: Transport<any, any, any>;
-    /** Specification of what the body of a request hitting this endpoint should look like (used for validation) */
-    inputParameters: InputParameters;
-    /** Specific details related to the rate limiting for this endpoint in particular */
-    rateLimiting?: EndpointRateLimitingConfig;
-}
-/**
- * Structure to describe an adapter that has been initialized
- */
-export interface InitializedAdapter extends Adapter {
-    /** Object containing alias translations for all endpoints */
-    endpointsMap: Record<string, AdapterEndpoint>;
-    /** Initialized dependencies that the adapter will use */
-    dependencies: AdapterDependencies;
-    /** Configuration params for various adapter properties */
-    config: AdapterConfig;
-}
-/**
- * This function will process dependencies for an adapter, such as caches or rate limiters,
- * in order to inject them into transports and other relevant places later in the lifecycle.
- *
- * @param config - the configuration for this adapter
- * @param inputDependencies - a partial obj of initialized dependencies to override the created ones
- * @param rateLimitingConfig - details from the adapter regarding rate limiting
- * @returns a set of AdapterDependencies all initialized
- */
-export declare const initializeDependencies: (adapter: Adapter, config: AdapterConfig, inputDependencies?: Partial<AdapterDependencies>) => AdapterDependencies;
-/**
- * Initializes all of the [[Transport]]s in the adapter, passing along any [[AdapterDependencies]] and [[AdapterConfig]].
- * Additionally, it builds a map out of all the endpoint names and aliases (checking for duplicates).
- *
- * @param adapter - an instance of an Adapter
- * @param dependencies - dependencies that the adapter will need at initialization
- * @param config - configuration variables already processed and validated
- * @returns - the adapter with all transports initialized and aliases map built
- */
-export declare const initializeAdapter: (adapter: Adapter, config: AdapterConfig, dependencies?: Partial<AdapterDependencies>) => Promise<InitializedAdapter>;
-export {};

package/background-executor.d.ts

@@ -1,11 +0,0 @@
-/// <reference types="node" />
-import { Server } from 'http';
-import { InitializedAdapter } from './adapter';
-/**
- * Very simple background loop that will call the [[Transport.backgroundExecute]] functions in all Transports.
- * It gets the time in ms to wait as the return value from those functions, and sleeps until next execution.
- *
- * @param adapter - an initialized External Adapter
- * @param server - the http server to attach an on close listener to
- */
-export declare function callBackgroundExecutes(adapter: InitializedAdapter, server?: Server): Promise<void>;

package/cache/factory.d.ts

@@ -1,6 +0,0 @@
-import { AdapterConfig } from '../config';
-import { LocalCache } from './local';
-import { RedisCache } from './redis';
-export declare class CacheFactory {
-    static buildCache(config: AdapterConfig): LocalCache<unknown> | RedisCache<unknown> | undefined;
-}