@chainlink/external-adapter-framework 0.0.19 → 0.0.20

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