@chainlink/external-adapter-framework 0.0.6 → 0.0.7

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("./expiring-sorted-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.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.js

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

package/dist/src/validation/error.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdapterError = void 0;
+class AdapterError extends Error {
+    constructor({ jobRunID = '1', status = 'errored', statusCode = 500, name = 'AdapterError', message = 'An error occurred.', cause, url, errorResponse, feedID, providerStatusCode, }) {
+        super(message);
+        this.jobRunID = jobRunID;
+        this.status = status;
+        this.statusCode = statusCode;
+        this.name = name;
+        this.message = message;
+        this.cause = cause;
+        if (url) {
+            this.url = url;
+        }
+        if (feedID) {
+            this.feedID = feedID;
+        }
+        this.errorResponse = errorResponse;
+        this.providerStatusCode = providerStatusCode;
+    }
+    toJSONResponse() {
+        const showDebugInfo = process.env['NODE_ENV'] === 'development' || process.env['DEBUG'] === 'true';
+        const errorBasic = {
+            name: this.name,
+            message: this.message,
+            url: this.url,
+            errorResponse: this.errorResponse,
+            feedID: this.feedID,
+        };
+        const errorFull = { ...errorBasic, stack: this.stack, cause: this.cause };
+        return {
+            jobRunID: this.jobRunID,
+            status: this.status,
+            statusCode: this.statusCode,
+            providerStatusCode: this.providerStatusCode,
+            error: showDebugInfo ? errorFull : errorBasic,
+        };
+    }
+}
+exports.AdapterError = AdapterError;

package/dist/src/validation/index.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorCatchingMiddleware = exports.validatorMiddleware = void 0;
+const cache_1 = require("../cache");
+const util_1 = require("../metrics/util");
+const util_2 = require("../util");
+const error_1 = require("./error");
+const validator_1 = require("./validator");
+const override_functions_1 = require("./override-functions");
+const errorCatcherLogger = (0, util_2.makeLogger)('ErrorCatchingMiddleware');
+const validatorMiddleware = (adapter) => (req, reply, done) => {
+    if (req.headers['content-type'] !== 'application/json') {
+        throw new error_1.AdapterError({
+            message: 'Content type not "application/json", returning 400',
+            statusCode: 400,
+        });
+    }
+    if (!req.body) {
+        throw new error_1.AdapterError({
+            message: 'Body not present in adapter request, returning 400',
+            statusCode: 400,
+        });
+    }
+    // Make endpoints case insensitive
+    const endpointParam = req.body.endpoint?.toLowerCase() || adapter.defaultEndpoint;
+    if (!endpointParam) {
+        throw new error_1.AdapterError({
+            message: `Request body does not specify an endpoint, and there is no default endpoint configured for this adapter.`,
+            statusCode: 400,
+        });
+    }
+    const endpoint = adapter.endpointsMap[endpointParam];
+    if (!endpoint) {
+        throw new error_1.AdapterError({
+            message: `Adapter does not have a "${req.body.endpoint}" endpoint.`,
+            statusCode: 404,
+        });
+    }
+    // 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',
+        cacheKey: '',
+        data: validator.validated.data,
+        endpointName: endpoint.name,
+    };
+    if (adapter.config.METRICS_ENABLED && adapter.config.EXPERIMENTAL_METRICS_ENABLED) {
+        // Add metrics meta which includes feedId to the request
+        // Perform prior to overrides to maintain consistent Feed IDs across adapters
+        const metricsMeta = (0, util_1.getMetricsMeta)(endpoint, validator.validated.data);
+        req.requestContext = { ...req.requestContext, metricsMeta };
+    }
+    // TODO: Support `includes` and `tokenOverrides` overrides as needed
+    const requestParams = req.requestContext.data ?? {};
+    if (requestParams['tokenOverrides']) {
+        throw new Error('Token overrides not yet supported');
+    }
+    if (requestParams['includes']) {
+        throw new Error('Includes not yet supported');
+    }
+    // Swaps the 'base' parameter if any overrides are found in the request or the adapter configuration
+    // Supports 'base' input as string or string[]
+    (0, override_functions_1.performSymbolOverrides)(adapter, req);
+    req.requestContext.cacheKey = (0, cache_1.calculateCacheKey)({
+        adapterEndpoint: endpoint,
+        adapterConfig: adapter.config,
+    }, req.requestContext.data);
+    done();
+};
+exports.validatorMiddleware = validatorMiddleware;
+const errorCatchingMiddleware = (err, req, res) => {
+    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.
+        errorCatcherLogger.warn(err);
+        res.status(err.statusCode).send(err.toJSONResponse());
+    }
+    else {
+        errorCatcherLogger.error(err);
+        res.status(200).send('There was an unexpected error in the adapter.');
+    }
+};
+exports.errorCatchingMiddleware = errorCatchingMiddleware;

package/dist/src/validation/input-params.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.baseInputParameters = void 0;
+exports.baseInputParameters = {
+    endpoint: {
+        description: 'The External Adapter "endpoint" name to use.',
+        required: false,
+        type: 'string',
+    },
+    resultPath: {
+        description: 'The path to key into the API response the retrieve the result',
+        required: false,
+        // Type: 'string', TODO: Once multiple types are supported this could be string or array of strings
+    },
+    overrides: {
+        description: 'Override the mapping of token symbols to another token symbol',
+        required: false,
+        // Type: 'string', TODO: Once complex types are supported this could be { [adapter: string]: { [token: string]: string } }
+    },
+    tokenOverrides: {
+        description: 'Override the mapping of token symbols to smart contract address',
+        required: false,
+        // Type: 'string', TODO: Once complex types are supported this could be { [network: string]: { [token: string]: string } }
+    },
+    includes: {
+        description: 'Override the array of includes that holds additional input parameters when matching a pair of symbols',
+        required: false,
+        // Type: 'string', TODO: Once complex types are supported this could be { from: string, to: string, includes: [{ from: string, to: string, adapters: string[], inverse: boolean, tokens: boolean }] } }[]
+    },
+};

package/dist/src/validation/override-functions.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.performSymbolOverrides = void 0;
+const performSymbolOverrides = (adapter, req) => {
+    let adapterOverrides = {};
+    if (req.requestContext.data &&
+        req.requestContext.data['overrides'] &&
+        req.requestContext.data['overrides'][adapter.name]) {
+        adapterOverrides = req.requestContext.data['overrides'][adapter.name];
+    }
+    if (!Array.isArray(req.requestContext.data['base'])) {
+        // Perform overrides specified in the request payload
+        req.requestContext.data['base'] =
+            adapterOverrides[req.requestContext.data['base']] ?? req.requestContext.data['base'];
+        // Perform hardcoded overrides
+        if (adapter.overrides) {
+            req.requestContext.data['base'] =
+                adapter.overrides[req.requestContext.data['base']] ??
+                    req.requestContext.data['base'];
+        }
+        return;
+    }
+    let requestedSymbols = req.requestContext.data['base'];
+    for (let i = 0; i < requestedSymbols.length; i++) {
+        const symbol = requestedSymbols[i];
+        // Perform overrides specified in the request payload
+        let overriddenSymbol = adapterOverrides[symbol.toUpperCase()] ?? adapterOverrides[symbol.toLowerCase()];
+        // Perform hardcoded overrides
+        if (adapter.overrides) {
+            overriddenSymbol =
+                adapter.overrides[symbol.toUpperCase()] ??
+                    adapter.overrides[symbol.toLowerCase()] ??
+                    overriddenSymbol;
+        }
+        requestedSymbols[i] = overriddenSymbol ?? requestedSymbols[i];
+    }
+    requestedSymbols = requestedSymbols.length > 1 ? requestedSymbols : requestedSymbols[1];
+    req.requestContext.data['base'] = requestedSymbols;
+};
+exports.performSymbolOverrides = performSymbolOverrides;

package/dist/src/validation/preset-tokens.json

@@ -0,0 +1,23 @@
+{
+    "ethereum": {
+        "LINK": "0x514910771af9ca656af840dff83e8264ecf986ca",
+        "WETH": "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
+        "ETH": "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
+        "stETH": "0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84",
+        "DIGG": "0x798d1be841a82a273720ce31c822c61a67a601c3",
+        "WBTC": "0x2260fac5e5542a773aa44fbcfedf7c193bc2c599",
+        "RAI": "0x03ab458634910aad20ef5f1c8ee96f1d6ac54919",
+        "RGT": "0xD291E7a03283640FDc51b121aC401383A46cC623",
+        "RARI": "0xFca59Cd816aB1eaD66534D82bc21E7515cE441CF",
+        "SFI": "0xb753428af26e81097e7fd17f40c88aaa3e04902c",
+        "LDO": "0x5a98fcbea516cf06857215779fd812ca3bef1b32",
+        "VSP": "0x1b40183EFB4Dd766f11bDa7A7c3AD8982e998421",
+        "USDC": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+        "USDT": "0xdAC17F958D2ee523a2206206994597C13D831ec7",
+        "DAI": "0x6B175474E89094C44Da98b954EedeAC495271d0F",
+        "FRAX": "0x853d955aCEf822Db058eb8505911ED77F175b99e",
+        "BOND": "0x0391d2021f89dc339f60fff84546ea23e337750f",
+        "FEI": "0x956f47f50a910163d8bf957cf5846d573e7f87ca",
+        "TRIBE": "0xc7283b66Eb1EB5FB86327f08e1B5816b0720212B"
+    }
+}

package/dist/src/validation/validator.js

@@ -0,0 +1,303 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Validator = void 0;
+const error_1 = require("./error");
+const input_params_1 = require("./input-params");
+const util_1 = require("../util");
+const preset_tokens_json_1 = __importDefault(require("./preset-tokens.json"));
+// Don't want to get requester in just yet, only copying the static method 'errored'
+const requesterErrored = (jobRunID = '1', error = undefined, statusCode = 500, feedID = undefined) => {
+    if (error instanceof error_1.AdapterError) {
+        error.jobRunID = jobRunID;
+        if (feedID) {
+            error.feedID = feedID;
+        }
+        return error.toJSONResponse();
+    }
+    if (error instanceof Error) {
+        return new error_1.AdapterError({
+            jobRunID,
+            statusCode,
+            message: error.message,
+            cause: error,
+            feedID,
+        }).toJSONResponse();
+    }
+    return new error_1.AdapterError({ jobRunID, statusCode, message: error, feedID }).toJSONResponse();
+};
+class Validator {
+    constructor(input = { id: '1', data: {} }, inputConfigs = {}, inputOptions = {}, validatorOptions = {}) {
+        // OverrideSymbol = (adapter: string, symbol?: string | string[]): string | string[] => {
+        //   Const defaultSymbol = symbol || this.validated.data.base
+        //   If (!defaultSymbol) this.throwInvalid(`Required parameter not supplied: base`)
+        //   // TODO: Will never be reached, because the presetSymbols are used as default overrides
+        //   If (!this.validated.overrides) return defaultSymbol
+        //   If (!Array.isArray(defaultSymbol))
+        //     Return (
+        //       This.validated.overrides.get(adapter.toLowerCase())?.get(defaultSymbol.toLowerCase()) ||
+        //       DefaultSymbol
+        //     )
+        //   Const multiple: string[] = []
+        //   For (const sym of defaultSymbol) {
+        //     Const overrided = this.validated.overrides.get(adapter.toLowerCase())?.get(sym.toLowerCase())
+        //     If (!overrided) multiple.push(sym)
+        //     Else multiple.push(overrided)
+        //   }
+        //   Return multiple
+        // }
+        // OverrideToken = (symbol: string, network = 'ethereum'): string | undefined => {
+        //   Return this.validated.tokenOverrides?.get(network.toLowerCase())?.get(symbol.toLowerCase())
+        // }
+        // OverrideIncludes = (from: string, to: string): IncludePair | undefined => {
+        //   // Search through `presetIncludes` to find matching override for adapter and to/from pairing.
+        //   Const pairs = (
+        //     This.validated.includes?.filter(
+        //       (val: string | Includes) => typeof val !== 'string',
+        //     ) as Includes[]
+        //   ).filter(
+        //     (pair) =>
+        //       Pair.from.toLowerCase() === from.toLowerCase() &&
+        //       Pair.to.toLowerCase() === to.toLowerCase(),
+        //   )
+        //   If (!pairs || !pairs[0] || !pairs[0].includes || !pairs[0].includes[0]) {
+        //     Return
+        //   }
+        //   Return pairs[0].includes[0]
+        // }
+        // OverrideReverseLookup = (adapter: string, type: OverrideType, symbol: string): string => {
+        //   Const overrides: Map<string, string> | undefined = this.validated?.[type]?.get(
+        //     Adapter.toLowerCase(),
+        //   )
+        //   If (!overrides) return symbol
+        //   Let originalSymbol: string | undefined
+        //   Overrides.forEach((overridden, original) => {
+        //     If (overridden.toLowerCase() === symbol.toLowerCase()) originalSymbol = original
+        //   })
+        //   Return originalSymbol || symbol
+        // }
+        this.formatOverride = (param) => {
+            const _throwInvalid = () => this.throwInvalid(`Parameter supplied with wrong format: "override"`);
+            if (!(0, util_1.isObject)(param)) {
+                _throwInvalid();
+            }
+            const _isValid = Object.values(param).every(util_1.isObject);
+            if (!_isValid) {
+                _throwInvalid();
+            }
+            const _keyToLowerCase = (entry) => {
+                return [entry[0].toLowerCase(), entry[1]];
+            };
+            return new Map(Object.entries(param)
+                .map(_keyToLowerCase)
+                .map(([key, value]) => [key, new Map(Object.entries(value).map(_keyToLowerCase))]));
+        };
+        this.formatIncludeOverrides = (param) => {
+            const _throwInvalid = () => this.throwInvalid(`Parameter supplied with wrong format: "includes"`);
+            if (!(0, util_1.isArray)(param)) {
+                _throwInvalid();
+            }
+            const _isValid = Object.values(param).every((val) => (0, util_1.isObject)(val) || typeof val === 'string');
+            if (!_isValid) {
+                _throwInvalid();
+            }
+            return param;
+        };
+        this.throwInvalid = (message) => {
+            throw new error_1.AdapterError({ jobRunID: this.validated.id, statusCode: 400, message });
+        };
+        this.input = { ...input };
+        if (!this.input.id) {
+            this.input.id = '1';
+        } // TODO Please remove these once "no any" strict typing is enabled
+        if (!this.input.data) {
+            this.input.data = {};
+        }
+        this.inputConfigs = { ...input_params_1.baseInputParameters, ...inputConfigs };
+        this.inputOptions = { ...inputOptions };
+        this.validatorOptions = {
+            shouldThrowError: true,
+            includes: [],
+            overrides: {},
+            ...validatorOptions,
+        };
+        this.validated = { id: this.input.id, data: {} };
+        this.validateInput();
+        this.validateOverrides('overrides', this.validatorOptions.overrides);
+        this.validateOverrides('tokenOverrides', preset_tokens_json_1.default);
+        this.validateIncludeOverrides();
+        this.checkDuplicateInputParams(inputConfigs);
+    }
+    validateInput() {
+        try {
+            for (const key in this.inputConfigs) {
+                this.validateObjectParam(key, this.validatorOptions.shouldThrowError);
+            }
+        }
+        catch (e) {
+            this.parseError(e);
+        }
+    }
+    validateOverrides(path, preset) {
+        try {
+            if (!this.input.data?.[path]) {
+                this.validated[path] = this.formatOverride(preset);
+                return;
+            }
+            this.validated[path] = this.formatOverride({ ...preset, ...this.input.data[path] });
+        }
+        catch (e) {
+            this.parseError(e);
+        }
+    }
+    checkDuplicateInputParams(inputConfig) {
+        let aliases = [];
+        for (const key in inputConfig) {
+            const param = inputConfig[key];
+            if (Array.isArray(param)) {
+                aliases = aliases.concat(param);
+            }
+            else if (typeof inputConfig === 'boolean') {
+                return;
+            }
+            else {
+                aliases.push(key);
+                if (typeof param === 'object' && 'aliases' in param && Array.isArray(param.aliases)) {
+                    aliases = aliases.concat(param.aliases);
+                }
+            }
+        }
+        if (aliases.length !== new Set(aliases).size) {
+            this.throwInvalid('Duplicate Input Aliases');
+        }
+    }
+    validateIncludeOverrides() {
+        try {
+            this.validated.includes = this.formatIncludeOverrides([
+                ...(Array.isArray(this.input.data?.includes) ? this.input.data.includes : []),
+                ...(this.validatorOptions.includes || []),
+            ]);
+        }
+        catch (e) {
+            this.parseError(e);
+        }
+    }
+    parseError(error) {
+        if (!(error instanceof Error)) {
+            return;
+        }
+        const message = 'Error validating input.';
+        if (error instanceof error_1.AdapterError) {
+            this.error = error;
+        }
+        else {
+            this.error = new error_1.AdapterError({
+                jobRunID: this.validated.id,
+                statusCode: 400,
+                message,
+                cause: error,
+            });
+        }
+        this.errored = requesterErrored(this.validated.id, this.error);
+        if (this.validatorOptions.shouldThrowError) {
+            throw this.error;
+        }
+    }
+    validateObjectParam(key, shouldThrowError = true) {
+        const inputConfig = this.inputConfigs[key];
+        const usedKey = this.getUsedKey(key, inputConfig.aliases ?? []);
+        const param = usedKey
+            ? this.input.data[usedKey] ?? inputConfig.default
+            : inputConfig.default;
+        if (shouldThrowError) {
+            const paramIsDefined = !(param === undefined || param === null || param === '');
+            if (inputConfig.required && !paramIsDefined) {
+                this.throwInvalid(`Required parameter ${key} must be non-null and non-empty`);
+            }
+            if (paramIsDefined) {
+                if (inputConfig.type) {
+                    const primitiveTypes = ['boolean', 'number', 'bigint', 'string'];
+                    if (![...primitiveTypes, 'array', 'object'].includes(inputConfig.type)) {
+                        this.throwInvalid(`${key} parameter has unrecognized type ${inputConfig.type}`);
+                    }
+                    if (primitiveTypes.includes(inputConfig.type) && typeof param !== inputConfig.type) {
+                        this.throwInvalid(`${key} parameter must be of type ${inputConfig.type}`);
+                    }
+                    if (inputConfig.type === 'array' && (!Array.isArray(param) || param.length === 0)) {
+                        this.throwInvalid(`${key} parameter must be a non-empty array`);
+                    }
+                    if (inputConfig.type === 'object' &&
+                        (!param ||
+                            Array.isArray(param) ||
+                            typeof param !== inputConfig.type ||
+                            Object.keys(param).length === 0)) {
+                        this.throwInvalid(`${key} parameter must be an object with at least one property`);
+                    }
+                }
+                // If (inputConfig.options) {
+                //   Const tolcase = (o: any) => (typeof o === 'string' ? o.toLowerCase() : o)
+                //   Const formattedOptions = inputConfig.options.map(tolcase)
+                //   Const formattedParam = tolcase(param)
+                //   If (!formattedOptions.includes(formattedParam))
+                //     This.throwInvalid(
+                //       `${key} parameter '${formattedParam}' is not in the set of available options: ${formattedOptions.join(
+                //         ',',
+                //       )}`,
+                //     )
+                // }
+                // For (const dependency of inputConfig.dependsOn ?? []) {
+                //   Const usedDependencyKey = this.getUsedKey(
+                //     Dependency,
+                //     (this.inputConfigs[dependency] as InputParameter).aliases ?? [],
+                //   )
+                //   If (!usedDependencyKey) this.throwInvalid(`${key} dependency ${dependency} not supplied`)
+                // }
+                // For (const exclusive of inputConfig.exclusive ?? []) {
+                //   Const usedExclusiveKey = this.getUsedKey(
+                //     Exclusive,
+                //     (this.inputConfigs[exclusive] as InputParameter).aliases ?? [],
+                //   )
+                //   If (usedExclusiveKey)
+                //     This.throwInvalid(`${key} cannot be supplied concurrently with ${exclusive}`)
+                // }
+            }
+        }
+        this.validated.data[key] = param;
+    }
+    validateOptionalParam(param, key, options) {
+        if (param && options) {
+            if (!Array.isArray(options)) {
+                this.throwInvalid(`Parameter options for ${key} must be of an Array type`);
+            }
+            if (!options.includes(param)) {
+                this.throwInvalid(`${param} is not a supported ${key} option. Must be one of ${options}`);
+            }
+        }
+        this.validated.data[key] = param;
+    }
+    validateRequiredParam(param, key, options) {
+        if (typeof param === 'undefined' || param === '') {
+            this.throwInvalid(`Required parameter not supplied: ${key}`);
+        }
+        if (options) {
+            if (!Array.isArray(options)) {
+                this.throwInvalid(`Parameter options for ${key} must be of an Array type`);
+            }
+            if (!options.includes(param)) {
+                this.throwInvalid(`${param} is not a supported ${key} option. Must be one of ${options.join(' || ')}`);
+            }
+        }
+        this.validated.data[key] = param;
+    }
+    getUsedKey(key, keyArray) {
+        const comparisonArray = [...keyArray];
+        if (!comparisonArray.includes(key)) {
+            comparisonArray.push(key);
+        }
+        const inputParamKeys = Object.keys(this.input.data);
+        return inputParamKeys.find((k) => comparisonArray.includes(k));
+    }
+}
+exports.Validator = Validator;

package/dist/test.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const _1 = require(".");
+const coingecko_1 = require("./examples/coingecko");
+// Start sample adapter
+(0, _1.expose)(coingecko_1.adapter);