@chainlink/external-adapter-framework 0.0.19 → 0.0.21

package/util/request.d.ts

@@ -0,0 +1,56 @@
+import { FastifyReply, FastifyRequest, HookHandlerDoneFunction } from 'fastify';
+import { Adapter } 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;
+};
+export declare type Middleware = ((req: AdapterRequest, reply: FastifyReply, done: HookHandlerDoneFunction) => FastifyReply | void) | ((req: AdapterRequest, reply: FastifyReply) => Promise<FastifyReply | void>);
+export declare type AdapterMiddlewareBuilder = (adapter: Adapter) => Middleware;

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

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

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

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

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

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: unknown;
+    url?: string;
+    errorResponse: unknown;
+    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 {};

package/validation/index.d.ts

@@ -0,0 +1,5 @@
+import { FastifyReply, FastifyRequest } from 'fastify';
+import { AdapterMiddlewareBuilder } from '../util/request';
+export { InputParameters } from './input-params';
+export declare const validatorMiddleware: AdapterMiddlewareBuilder;
+export declare const errorCatchingMiddleware: (err: Error, req: FastifyRequest, res: FastifyReply) => void;

package/validation/index.js

@@ -39,7 +39,6 @@ const validatorMiddleware = (adapter) => (req, reply, done) => {
         });
     }
     // Validate data using validator from v2
-    // TODO: See if we want to change this whole thing
     const validator = new validator_1.Validator(req.body, endpoint.inputParameters);
     req.requestContext = {
         id: req.body.id || '1',
@@ -76,7 +75,10 @@ const validatorMiddleware = (adapter) => (req, reply, done) => {
 exports.validatorMiddleware = validatorMiddleware;
 const errorCatchingMiddleware = (err, req, res) => {
     // Add adapter or generic error to request meta for metrics use
-    req.requestContext.meta = { ...req.requestContext.meta, error: err };
+    // There's a chance we have no request context if there was an error during input validation
+    if (req.requestContext) {
+        req.requestContext.meta = { ...req.requestContext?.meta, error: err };
+    }
     if (err instanceof error_1.AdapterError) {
         // We want to log these as warn, because although they are to be expected, NOPs should
         // Only use "correct" job specs and therefore not hit adapters with invalid requests.

package/validation/input-params.d.ts

@@ -0,0 +1,15 @@
+export declare type Override = Map<string, Map<string, string>>;
+export declare type InputParameter = {
+    aliases?: string[];
+    description?: string;
+    type?: 'bigint' | 'boolean' | 'array' | 'number' | 'object' | 'string';
+    required?: boolean;
+    options?: unknown[];
+    default?: unknown;
+    dependsOn?: string[];
+    exclusive?: string[];
+};
+export declare type InputParameters = {
+    [name: string]: InputParameter | boolean | string[];
+};
+export declare const baseInputParameters: InputParameters;

package/validation/override-functions.d.ts

@@ -0,0 +1,3 @@
+import { Adapter } from '../adapter';
+import { AdapterRequest } from '../util/request';
+export declare const performSymbolOverrides: (adapter: Adapter, req: AdapterRequest) => void;

package/validation/validator.d.ts

@@ -0,0 +1,47 @@
+import { AdapterError, AdapterErrorResponse } from './error';
+import { InputParameters, Override } from './input-params';
+export declare type OverrideType = 'overrides' | 'tokenOverrides' | 'includes';
+declare type InputType = {
+    id?: string;
+    data?: any;
+};
+export interface ValidatorOptions {
+    shouldThrowError?: boolean;
+    includes?: any[];
+    overrides?: any;
+}
+export declare type IncludePair = {
+    from: string;
+    to: string;
+    adapters?: string[];
+    inverse?: boolean;
+    tokens?: boolean;
+};
+export declare type Includes = {
+    from: string;
+    to: string;
+    includes: IncludePair[];
+};
+export declare class Validator {
+    input: InputType;
+    inputConfigs: InputParameters;
+    inputOptions: Record<string, any[]>;
+    validatorOptions: ValidatorOptions;
+    validated: any;
+    error: AdapterError | undefined;
+    errored: AdapterErrorResponse | undefined;
+    constructor(input?: InputType, inputConfigs?: {}, inputOptions?: {}, validatorOptions?: ValidatorOptions);
+    validateInput(): void;
+    validateOverrides(path: 'overrides' | 'tokenOverrides', preset: Record<string, any>): void;
+    checkDuplicateInputParams(inputConfig: InputParameters): void;
+    validateIncludeOverrides(): void;
+    parseError(error: unknown): void;
+    formatOverride: (param: any) => Override;
+    formatIncludeOverrides: (param: any) => Override;
+    throwInvalid: (message: string) => void;
+    validateObjectParam(key: string, shouldThrowError?: boolean): void;
+    validateOptionalParam(param: any, key: string, options: any[]): void;
+    validateRequiredParam(param: any, key: string, options: any[]): void;
+    getUsedKey(key: string, keyArray: string[]): string | undefined;
+}
+export {};