@chainlink/external-adapter-framework 0.0.10 → 0.0.12

package/dist/src/transports/websocket.js

@@ -0,0 +1,166 @@
+"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 = void 0;
+const ws_1 = __importDefault(require("ws"));
+const util_1 = require("../util");
+const _1 = require("./");
+const transportMetrics = __importStar(require("./metrics"));
+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, config) {
+        logger.debug(`Adding entry to subscription set: [${req.requestContext.cacheKey}] = ${req.requestContext.data}`);
+        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
+    // 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. (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
+                // 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/dist/src/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/dist/src/util/expiring-sorted-set.js

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

@@ -0,0 +1,12 @@
+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/dist/src/util/index.js

@@ -0,0 +1,35 @@
+"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/dist/src/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/dist/src/util/logger.js

@@ -0,0 +1,62 @@
+"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/dist/src/util/request.d.ts

@@ -0,0 +1,57 @@
+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;
+    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: Adapter) => Middleware;

package/dist/src/util/request.js

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

package/dist/src/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/dist/src/util/subscription-set/expiring-sorted-set.js

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

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

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadTestPayload = void 0;
+const ajv_1 = __importDefault(require("ajv"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const logger_1 = require("./logger");
+const logger = (0, logger_1.makeLogger)('TestPayloadLoader');
+/**
+ * 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
+ */
+function loadTestPayload(fileName) {
+    const ajv = new ajv_1.default();
+    const schema = {
+        type: 'object',
+        required: ['requests'],
+        properties: {
+            requests: {
+                type: 'array',
+                items: {
+                    type: 'object',
+                    required: [],
+                },
+            },
+        },
+    };
+    const validate = ajv.compile(schema);
+    try {
+        const payload = resolvePayload(fileName);
+        if (!validate(payload) || !payload?.requests) {
+            throw Error(JSON.stringify(validate?.errors || 'Could not validate schema for test payload'));
+        }
+        return { ...payload, isDefault: false };
+    }
+    catch (e) {
+        logger.warn(`Could not load payload: ${e.message}`);
+        logger.warn('Falling back to default empty payload');
+        return { isDefault: true };
+    }
+}
+exports.loadTestPayload = loadTestPayload;
+function resolvePayload(fileName) {
+    try {
+        let payload = null;
+        // Find test payload by specified name, fallback to default names if not found
+        if (fileName && fs_1.default.existsSync(path_1.default.join(process.cwd(), fileName))) {
+            payload = require(path_1.default.join(process.cwd(), fileName));
+        }
+        else if (fileName && fs_1.default.existsSync(`./${fileName}`)) {
+            payload = require(`./${fileName}`);
+        }
+        // Search for test payload js first if no filename specified or found
+        else if (fs_1.default.existsSync(path_1.default.resolve('.', 'test-payload.js'))) {
+            payload = require(path_1.default.join(process.cwd(), 'test-payload.js'));
+        }
+        else if (fs_1.default.existsSync(`./test-payload.js`)) {
+            payload = require(`./test-payload.js`);
+        }
+        // Search for test payload json second if no filename specified or found
+        else if (fs_1.default.existsSync(path_1.default.join(process.cwd(), 'test-payload.json'))) {
+            payload = require(path_1.default.join(process.cwd(), 'test-payload.json'));
+        }
+        else if (fs_1.default.existsSync(`./test-payload.json`)) {
+            payload = require(`./test-payload.json`);
+        }
+        if (typeof payload === 'string') {
+            return JSON.parse(payload);
+        }
+        else {
+            return payload;
+        }
+    }
+    catch {
+        return null;
+    }
+}