@chainlink/external-adapter-framework 0.0.7 → 0.0.10

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

@@ -23,8 +23,9 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.cacheWarmerCount = exports.wsMessageTotal = exports.wsSubscriptionErrors = exports.wsSubscriptionTotal = exports.wsSubscriptionActive = exports.wsConnectionRetries = exports.wsConnectionErrors = exports.wsConnectionActive = exports.messageLabels = exports.subscriptionErrorLabels = exports.subscriptionLabels = exports.connectionErrorLabels = exports.connectionLabels = exports.dataProviderRequestDurationSeconds = exports.dataProviderRequests = exports.dataProviderMetricsLabel = void 0;
+exports.wsMessageTotal = exports.wsSubscriptionTotal = exports.wsSubscriptionActive = exports.wsConnectionErrors = exports.wsConnectionActive = exports.recordWsMessageMetrics = exports.messageSubsLabels = exports.connectionErrorLabels = exports.dataProviderRequestDurationSeconds = exports.dataProviderRequests = exports.dataProviderMetricsLabel = void 0;
 const client = __importStar(require("prom-client"));
+const cache_1 = require("../cache");
 const constants_1 = require("../metrics/constants");
 // Data Provider Metrics
 const dataProviderMetricsLabel = (providerStatusCode, method = 'get') => ({
@@ -43,38 +44,40 @@ exports.dataProviderRequestDurationSeconds = new client.Histogram({
     buckets: constants_1.requestDurationBuckets,
 });
 // Websocket Metrics
-const connectionLabels = (key) => ({
-// Key,
-});
-exports.connectionLabels = connectionLabels;
 const connectionErrorLabels = (message) => ({
     // Key,
     message,
 });
 exports.connectionErrorLabels = connectionErrorLabels;
-const subscriptionLabels = (
-// Connection_key: string,
-feed_id, cache_key) => ({
-    // Connection_key,
-    feed_id,
-    subscription_key: cache_key,
-});
-exports.subscriptionLabels = subscriptionLabels;
-const subscriptionErrorLabels = (
-// Connection_key: string,
-input, message, type) => ({
-    // Connection_key,
-    feed_id: input ? input.metricsMeta?.feedId : 'N/A',
-    message,
-    subscription_key: input.cacheKey ? input.cacheKey : 'N/A',
-    type,
-});
-exports.subscriptionErrorLabels = subscriptionErrorLabels;
-const messageLabels = (feed_id, cache_key) => ({
+const messageSubsLabels = (feed_id, cache_key) => ({
     feed_id,
     subscription_key: cache_key,
 });
-exports.messageLabels = messageLabels;
+exports.messageSubsLabels = messageSubsLabels;
+// Record WS message and subscription metrics
+// Recalculate cacheKey and feedId for metrics
+// 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 cacheKey = (0, cache_1.calculateCacheKey)(context, param);
+        // Record total number of ws messages sent
+        exports.wsMessageTotal.labels((0, exports.messageSubsLabels)(feedId, cacheKey)).inc();
+        // Record total number of subscriptions made
+        exports.wsSubscriptionTotal.labels((0, exports.messageSubsLabels)(feedId, cacheKey)).inc();
+        // Record number of active ws subscriptions
+        exports.wsSubscriptionActive.labels((0, exports.messageSubsLabels)(feedId, cacheKey)).inc();
+    });
+    unsubscrices.forEach((param) => {
+        const feedId = (0, cache_1.calculateFeedId)(context.adapterEndpoint, 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();
+        // Record number of active ws subscriptions
+        exports.wsSubscriptionActive.labels((0, exports.messageSubsLabels)(feedId, cacheKey)).dec();
+    });
+};
+exports.recordWsMessageMetrics = recordWsMessageMetrics;
 exports.wsConnectionActive = new client.Gauge({
     name: 'ws_connection_active',
     help: 'The number of active connections',
@@ -85,12 +88,6 @@ exports.wsConnectionErrors = new client.Counter({
     help: 'The number of connection errors',
     labelNames: ['url', 'message'],
 });
-// Doesn't seem to be any retry connection functionality yet
-exports.wsConnectionRetries = new client.Counter({
-    name: 'ws_connection_retries',
-    help: 'The number of connection retries',
-    labelNames: ['url'],
-});
 exports.wsSubscriptionActive = new client.Gauge({
     name: 'ws_subscription_active',
     help: 'The number of currently active subscriptions',
@@ -101,19 +98,8 @@ exports.wsSubscriptionTotal = new client.Counter({
     help: 'The number of subscriptions opened in total',
     labelNames: ['connection_url', 'feed_id', 'subscription_key'],
 });
-exports.wsSubscriptionErrors = new client.Counter({
-    name: 'ws_subscription_errors',
-    help: 'The number of subscriptions errors',
-    labelNames: ['connection_url', 'feed_id', 'subscription_key', 'message', 'type'],
-});
 exports.wsMessageTotal = new client.Counter({
     name: 'ws_message_total',
     help: 'The number of messages received in total',
     labelNames: ['feed_id', 'subscription_key'],
 });
-// Cache Warmer Metrics
-exports.cacheWarmerCount = new client.Gauge({
-    name: 'cache_warmer_get_count',
-    help: 'The number of cache warmers running',
-    labelNames: ['isBatched'],
-});

package/transports/rest.d.ts

@@ -0,0 +1,43 @@
+import { AdapterRequest, AdapterResponse } from '../util/request';
+import { AdapterDependencies, Transport } from './';
+import { Cache } from '../cache';
+import { AxiosRequestConfig, AxiosResponse } from 'axios';
+import { AdapterConfig, SettingsMap } from '../config';
+import { RequestRateLimiter } from '../rate-limiting';
+/**
+ * Transport implementation that takes incoming requests, transforms them into a DataProvider request,
+ * and executes that request returning the response immediately from the `setup` function.
+ * Optionally, setting the `coalescing` option to `true` will make it so once a request is in flight,
+ * new adapter requests for the same feed will not trigger a new one, but return an empty promise from
+ * the setup instead so the normal cache polling mechanism is used.
+ *
+ * @typeParam AdapterParams - interface for the adapter request body
+ * @typeParam ProviderRequestBody - interface for the body of the request to the Data Provider
+ * @typeParam ProviderResponseBody - interface for the body of the Data Provider's response
+ */
+export declare class RestTransport<AdapterParams, ProviderRequestBody, ProviderResponseBody, CustomSettings extends SettingsMap> implements Transport<AdapterParams, ProviderResponseBody, CustomSettings> {
+    protected config: {
+        prepareRequest: (req: AdapterRequest<AdapterParams>, config: AdapterConfig<CustomSettings>) => AxiosRequestConfig<ProviderRequestBody> | Promise<AxiosRequestConfig<ProviderRequestBody>>;
+        parseResponse: (req: AdapterRequest<AdapterParams>, res: AxiosResponse<ProviderResponseBody>, config: AdapterConfig<CustomSettings>) => AdapterResponse<ProviderResponseBody> | Promise<AdapterResponse<ProviderResponseBody>>;
+        options: {
+            coalescing: boolean;
+        };
+    };
+    inFlightPrefix: string;
+    cache: Cache;
+    rateLimiter: RequestRateLimiter;
+    constructor(config: {
+        prepareRequest: (req: AdapterRequest<AdapterParams>, config: AdapterConfig<CustomSettings>) => AxiosRequestConfig<ProviderRequestBody> | Promise<AxiosRequestConfig<ProviderRequestBody>>;
+        parseResponse: (req: AdapterRequest<AdapterParams>, res: AxiosResponse<ProviderResponseBody>, config: AdapterConfig<CustomSettings>) => AdapterResponse<ProviderResponseBody> | Promise<AdapterResponse<ProviderResponseBody>>;
+        options: {
+            coalescing: boolean;
+        };
+    });
+    initialize(dependencies: AdapterDependencies): Promise<void>;
+    hasBeenSetUp(req: AdapterRequest<AdapterParams>): Promise<boolean>;
+    protected waitUntilUnderRateLimit(options: {
+        maxRetries: number;
+        msBetweenRetries: number;
+    }, retry?: number): Promise<void>;
+    setup(req: AdapterRequest<AdapterParams>, config: AdapterConfig<CustomSettings>): Promise<AdapterResponse<ProviderResponseBody> | undefined>;
+}

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

@@ -1,9 +1,33 @@
 "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;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RestTransport = void 0;
 const util_1 = require("../util");
 const error_1 = require("../validation/error");
 const util_2 = require("./util");
+const rateLimitMetrics = __importStar(require("../rate-limiting/metrics"));
 const IN_FLIGHT_PREFIX = 'InFlight';
 const logger = (0, util_1.makeLogger)('RestTransport');
 /**
@@ -77,11 +101,23 @@ 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.metricsMeta = { feedId: req.requestContext.metricsMeta?.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);
-        // TODO: Record rate limit credit with cost, default 1
+        // Record cost of data provider call
+        const cost = rateLimitMetrics.retrieveCost(providerResponse.data);
+        rateLimitMetrics.rateLimitCreditsSpentTotal
+            .labels({
+            feed_id: req.requestContext.meta?.metrics?.feedId || 'N/A',
+            participant_id: req.requestContext.cacheKey,
+        })
+            .inc(cost);
+        // Update cacheHit flag in request meta for metrics use
+        req.requestContext.meta = {
+            ...req.requestContext.meta,
+            metrics: { ...req.requestContext.meta?.metrics, cacheHit: false },
+        };
         // TODO: move this to a try/catch/finally
         if (this.config.options.coalescing) {
             logger.debug('Set provider response in cache, removing in flight from cache');

package/transports/util.d.ts

@@ -0,0 +1,8 @@
+import { AxiosRequestConfig, AxiosResponse } from 'axios';
+/**
+ * Performs axios request along with metrics recording and error handling
+ *
+ * @param request - axios request config
+ * @returns axios response for the request
+ */
+export declare function axiosRequest<ProviderRequestBody, ProviderResponseBody>(request: AxiosRequestConfig<ProviderRequestBody>): Promise<AxiosResponse<ProviderResponseBody>>;

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

@@ -46,31 +46,31 @@ async function axiosRequest(request) {
         const error = e;
         // Request error
         let providerStatusCode;
-        let name;
-        let statusCode;
+        let adapterError;
         if (error.code === 'ECONNABORTED') {
+            adapterError = new error_1.AdapterTimeoutError({});
             providerStatusCode = error?.response?.status ?? 504;
-            name = 'Data Provider Request Timeout error';
-            statusCode = 504;
+            adapterError.name = 'Data Provider Request Timeout error';
+        }
+        else if (error?.response?.status) {
+            adapterError = new error_1.AdapterDataProviderError({});
+            providerStatusCode = error?.response?.status;
         }
         else {
-            providerStatusCode = error?.response?.status ?? 0; // 0 -> connection error
-            statusCode = 200;
+            adapterError = new error_1.AdapterConnectionError({});
+            providerStatusCode = 0; // 0 -> connection error
         }
         // Record count of failed data provider request
         transportMetrics.dataProviderRequests
             .labels(transportMetrics.dataProviderMetricsLabel(providerStatusCode, request.method))
             .inc();
-        // TODO: Use specific AdapterErrors once ported over (AdapterTimeoutError, AdapterConnectionError, AdapterDataProviderError)
-        throw new error_1.AdapterError({
-            statusCode,
-            name,
-            providerStatusCode,
-            message: error?.message,
-            cause: error,
-            errorResponse: error?.response?.data,
-            url: request.url,
-        });
+        adapterError.statusCode = 200;
+        adapterError.providerStatusCode = providerStatusCode;
+        adapterError.message = error?.message;
+        adapterError.cause = error;
+        adapterError.errorResponse = error?.response?.data;
+        adapterError.url = request.url;
+        throw adapterError;
     }
     finally {
         // Record time taken for data provider request for success or failure

package/transports/websocket.d.ts

@@ -0,0 +1,80 @@
+import WebSocket from 'ws';
+import { Cache } from '../cache';
+import { SettingsMap } from '../config';
+import { BackgroundExecuteRateLimiter } from '../rate-limiting';
+import { ExpiringSortedSet } from '../util';
+import { AdapterRequest, ProviderResult } from '../util/request';
+import { AdapterContext, AdapterDependencies, 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 [[ExpiringSortedSet]] 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;
+    expiringSortedSet: ExpiringSortedSet<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/{dist/src/transports → transports}/websocket.js

@@ -90,7 +90,7 @@ class WebSocketTransport {
                 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.labels({ url: this.config.url }).inc();
+                transportMetrics.wsConnectionActive.inc();
                 resolve(true);
             });
             this.wsConnection.addEventListener('message', async (event) => {
@@ -114,7 +114,7 @@ class WebSocketTransport {
                 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.labels({ url: this.config.url }).dec();
+                transportMetrics.wsConnectionActive.dec();
             });
         });
     }
@@ -124,12 +124,12 @@ class WebSocketTransport {
         const desiredSubs = this.expiringSortedSet.getAll();
         logger.debug('Generating delta (subscribes & unsubscribes)');
         // TODO: More efficient algorithm, this is really easy to read, but high(er) time complexity
-        const subscribes = desiredSubs
-            .filter((s) => !this.localSubscriptions.includes(s))
+        const subscribeParams = desiredSubs.filter((s) => !this.localSubscriptions.includes(s));
+        const subscribes = subscribeParams
             .map(this.config.builders.subscribeMessage)
             .map(this.serializeMessage);
-        const unsubscribes = this.localSubscriptions
-            .filter((s) => !desiredSubs.includes(s))
+        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`);
@@ -152,20 +152,14 @@ class WebSocketTransport {
             await this.establishWsConnection(context);
         }
         // TODO: Close connection at some point?
-        // TODO: Finish ws metrics
         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 total number of ws messages sent
-            // ws_message_total.labels(messageLabels(this.config.key)).inc()
         }
-        // Record number of total subscriptions made
-        // ws_subscription_total.labels(subscriptionLabels(this.config.key)).inc(subscribes.length())
-        // Record number of active ws subscriptions
-        // const activeSubCount = desiredSubs ? desiredSubs.length : 0
-        // ws_subscription_active.labels(subscriptionLabels(this.config.key)).set(activeSubCount)
+        // 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');

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

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

@@ -0,0 +1,11 @@
+export * from './request';
+export * from './logger';
+export * from './expiring-sorted-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;

package/util/logger.d.ts

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

@@ -0,0 +1,55 @@
+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>;
+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/validation/error.d.ts

@@ -0,0 +1,50 @@
+import { HttpRequestType } from "../metrics/constants";
+declare type ErrorBasic = {
+    name: string;
+    message: string;
+};
+declare type ErrorFull = ErrorBasic & {
+    stack: string;
+    cause: string;
+};
+export declare type AdapterErrorResponse = {
+    jobRunID: string;
+    status: string;
+    statusCode: number;
+    providerStatusCode?: number;
+    error: ErrorBasic | ErrorFull;
+};
+export declare class AdapterError extends Error {
+    jobRunID: string;
+    status: string;
+    statusCode: number;
+    cause: any;
+    url?: string;
+    errorResponse: any;
+    feedID?: string;
+    providerStatusCode?: number;
+    metricsLabel?: HttpRequestType;
+    name: string;
+    message: string;
+    constructor({ jobRunID, status, statusCode, name, message, cause, url, errorResponse, feedID, providerStatusCode, metricsLabel }: Partial<AdapterError>);
+    toJSONResponse(): AdapterErrorResponse;
+}
+export declare class AdapterInputError extends AdapterError {
+    constructor(input: Partial<AdapterError>);
+}
+export declare class AdapterRateLimitError extends AdapterError {
+    constructor(input: Partial<AdapterError>);
+}
+export declare class AdapterTimeoutError extends AdapterError {
+    constructor(input: Partial<AdapterError>);
+}
+export declare class AdapterDataProviderError extends AdapterError {
+    constructor(input: Partial<AdapterError>);
+}
+export declare class AdapterConnectionError extends AdapterError {
+    constructor(input: Partial<AdapterError>);
+}
+export declare class AdapterCustomError extends AdapterError {
+    constructor(input: Partial<AdapterError>);
+}
+export {};