@chainlink/external-adapter-framework 0.0.15 → 0.0.17

package/src/validation/validator.ts

@@ -1,384 +0,0 @@
-import { AdapterError, AdapterErrorResponse } from './error'
-import { InputParameter, InputParameters, Override, baseInputParameters } from './input-params'
-import { isArray, isObject } from '../util'
-import presetTokens from './preset-tokens.json'
-
-export type OverrideType = 'overrides' | 'tokenOverrides' | 'includes'
-
-type InputType = {
-  id?: string
-  data?: any
-}
-
-export interface ValidatorOptions {
-  shouldThrowError?: boolean
-  includes?: any[]
-  overrides?: any
-}
-
-// Includes is an alternative symbol mapping that can be used to represent
-// The original request, such as wrapped tokens on DEXes.
-export type IncludePair = {
-  from: string // From symbol
-  to: string // To symbol
-  adapters?: string[] // Array of adapters this applies to
-  inverse?: boolean // If the inverse should be calculated instead
-  tokens?: boolean // If the token addresses should be used instead
-}
-
-export type Includes = {
-  from: string
-  to: string
-  includes: IncludePair[]
-}
-
-// Don't want to get requester in just yet, only copying the static method 'errored'
-const requesterErrored = (
-  jobRunID = '1',
-  error: AdapterError | Error | string | undefined = undefined,
-  statusCode = 500,
-  feedID: string | undefined = undefined,
-): AdapterErrorResponse => {
-  if (error instanceof AdapterError) {
-    error.jobRunID = jobRunID
-    if (feedID) {
-      error.feedID = feedID
-    }
-    return error.toJSONResponse()
-  }
-  if (error instanceof Error) {
-    return new AdapterError({
-      jobRunID,
-      statusCode,
-      message: error.message,
-      cause: error,
-      feedID,
-    }).toJSONResponse()
-  }
-  return new AdapterError({ jobRunID, statusCode, message: error, feedID }).toJSONResponse()
-}
-
-export class Validator {
-  input: InputType
-  inputConfigs: InputParameters
-  inputOptions: Record<string, any[]>
-  validatorOptions: ValidatorOptions
-  validated: any
-  error: AdapterError | undefined
-  errored: AdapterErrorResponse | undefined
-  constructor(
-    input: InputType = { id: '1', data: {} },
-    inputConfigs = {},
-    inputOptions = {},
-    validatorOptions: ValidatorOptions = {},
-  ) {
-    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 = { ...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', presetTokens)
-    this.validateIncludeOverrides()
-    this.checkDuplicateInputParams(inputConfigs)
-  }
-
-  validateInput(): void {
-    try {
-      for (const key in this.inputConfigs) {
-        this.validateObjectParam(key, this.validatorOptions.shouldThrowError)
-      }
-    } catch (e) {
-      this.parseError(e)
-    }
-  }
-
-  validateOverrides(path: 'overrides' | 'tokenOverrides', preset: Record<string, any>): void {
-    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: InputParameters): void {
-    let aliases: string[] = []
-    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(): void {
-    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: unknown): void {
-    if (!(error instanceof Error)) {
-      return
-    }
-    const message = 'Error validating input.'
-    if (error instanceof AdapterError) {
-      this.error = error
-    } else {
-      this.error = new 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
-    }
-  }
-
-  // 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
-  // }
-
-  formatOverride = (param: any): Override => {
-    const _throwInvalid = () =>
-      this.throwInvalid(`Parameter supplied with wrong format: "override"`)
-
-    if (!isObject(param)) {
-      _throwInvalid()
-    }
-
-    const _isValid = Object.values(param).every(isObject)
-    if (!_isValid) {
-      _throwInvalid()
-    }
-
-    const _keyToLowerCase = (entry: [string, any]): [string, any] => {
-      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))]),
-    )
-  }
-
-  formatIncludeOverrides = (param: any): Override => {
-    const _throwInvalid = () =>
-      this.throwInvalid(`Parameter supplied with wrong format: "includes"`)
-    if (!isArray(param)) {
-      _throwInvalid()
-    }
-
-    const _isValid = Object.values(param).every((val) => isObject(val) || typeof val === 'string')
-    if (!_isValid) {
-      _throwInvalid()
-    }
-
-    return param
-  }
-
-  throwInvalid = (message: string): void => {
-    throw new AdapterError({ jobRunID: this.validated.id, statusCode: 400, message })
-  }
-
-  validateObjectParam(key: string, shouldThrowError = true): void {
-    const inputConfig = this.inputConfigs[key] as InputParameter
-    const usedKey = this.getUsedKey(key, inputConfig.aliases ?? [])
-
-    const param = usedKey
-      ? this.input.data[usedKey as string] ?? 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: any, key: string, options: any[]): void {
-    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: any, key: string, options: any[]): void {
-    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: string, keyArray: string[]): string | undefined {
-    const comparisonArray = [...keyArray]
-    if (!comparisonArray.includes(key)) {
-      comparisonArray.push(key)
-    }
-
-    const inputParamKeys = Object.keys(this.input.data)
-    return inputParamKeys.find((k) => comparisonArray.includes(k))
-  }
-}

package/test/adapter.test.ts

@@ -1,27 +0,0 @@
-import test from 'ava'
-import { expose } from '../src'
-import { Adapter } from '../src/adapter'
-import { NopTransport } from './util'
-
-test('duplicate endpoint names throw error on startup', async (t) => {
-  const adapter: Adapter = {
-    name: 'test',
-    endpoints: [
-      {
-        name: 'test',
-        inputParameters: {},
-        transport: new NopTransport(),
-      },
-      {
-        name: 'another',
-        aliases: ['test'],
-        inputParameters: {},
-        transport: new NopTransport(),
-      },
-    ],
-  }
-
-  await t.throwsAsync(async () => expose(adapter), {
-    message: 'Duplicate endpoint / alias: "test"',
-  })
-})

package/test/background-executor.test.ts

@@ -1,108 +0,0 @@
-import test from 'ava'
-import FakeTimers from '@sinonjs/fake-timers'
-import { expose } from '../src'
-import { Adapter, AdapterContext } from '../src/adapter'
-import { deferredPromise, NopTransport } from './util'
-
-test('background executor calls transport function with background context', async (t) => {
-  const [promise, resolve] = deferredPromise<AdapterContext>()
-
-  const transport = new (class extends NopTransport {
-    async backgroundExecute(context: AdapterContext): Promise<number> {
-      resolve(context)
-      return 100
-    }
-  })()
-
-  const adapter: Adapter = {
-    name: 'test',
-    endpoints: [
-      {
-        name: 'test',
-        inputParameters: {},
-        transport,
-      },
-      {
-        name: 'skipped',
-        inputParameters: {},
-        transport: new NopTransport(), // Also add coverage for skipped executors
-      },
-    ],
-  }
-
-  await expose(adapter)
-  const context = await promise
-  t.is(context.adapterEndpoint.name, 'test')
-})
-
-// Needs to be serial to avoid mocking global clock more than once at the same time
-// TODO: Inject clock?
-test.serial(
-  'background executor calls transport function second time after sleeping',
-  async (t) => {
-    const clock = FakeTimers.install()
-    let timesCalled = 0
-
-    const transport = new (class extends NopTransport {
-      async backgroundExecute(): Promise<number> {
-        timesCalled++
-        return 1000
-      }
-    })()
-
-    const adapter: Adapter = {
-      name: 'test',
-      endpoints: [
-        {
-          name: 'test',
-          inputParameters: {},
-          aliases: ['other'], // Add an alias to ensure it's not called once per alias
-          transport,
-        },
-      ],
-    }
-
-    await expose(adapter)
-    t.is(timesCalled, 1)
-    await clock.tickAsync(999)
-    t.is(timesCalled, 1)
-    await clock.tickAsync(1)
-    t.is(timesCalled, 2)
-
-    clock.uninstall()
-  },
-)
-
-test.serial('background executor ends recursive chain on server close', async (t) => {
-  const clock = FakeTimers.install()
-  let timesCalled = 0
-
-  const transport = new (class extends NopTransport {
-    async backgroundExecute(): Promise<number> {
-      timesCalled++
-      return 1000
-    }
-  })()
-
-  const adapter: Adapter = {
-    name: 'test',
-    endpoints: [
-      {
-        name: 'test',
-        inputParameters: {},
-        transport,
-      },
-    ],
-  }
-
-  const server = await expose(adapter)
-  if (!server) {
-    throw 'Server did not start'
-  }
-  t.is(timesCalled, 1)
-  server.close()
-  await clock.tickAsync(999999)
-  t.is(timesCalled, 1) // The background process closed, so this was never called again
-
-  clock.uninstall()
-})

package/test/cache/cache-key.test.ts

@@ -1,114 +0,0 @@
-import untypedTest, { TestFn } from 'ava'
-import axios from 'axios'
-import { AddressInfo } from 'net'
-import { expose } from '../../src'
-import { Adapter, AdapterEndpoint } from '../../src/adapter'
-import { Cache } from '../../src/cache'
-import { BaseSettings } from '../../src/config'
-import { AdapterRequest, AdapterResponse } from '../../src/util'
-import { NopTransport } from '../util'
-
-const test = untypedTest as TestFn<{
-  serverAddress: string
-  cache: Cache
-  adapterEndpoint: AdapterEndpoint
-}>
-
-test.beforeEach(async (t) => {
-  const adapter: Adapter = {
-    name: 'test',
-    defaultEndpoint: 'test',
-    endpoints: [
-      {
-        name: 'test',
-        inputParameters: {},
-        transport: new (class extends NopTransport {
-          override async setup(
-            req: AdapterRequest<unknown>,
-          ): Promise<void | AdapterResponse<null>> {
-            return {
-              data: null,
-              statusCode: 200,
-              result: req.requestContext.cacheKey,
-            }
-          }
-        })(),
-      },
-    ],
-    envDefaultOverrides: {
-      MAX_COMMON_KEY_SIZE: 100,
-    },
-  }
-
-  t.context.adapterEndpoint = adapter.endpoints[0]
-  const server = await expose(adapter)
-  if (!server) {
-    throw 'Server did not start'
-  }
-  t.context.serverAddress = `http://localhost:${(server.address() as AddressInfo).port}`
-})
-
-test.serial('no parameters returns default cache key', async (t) => {
-  const response = await axios.post(`${t.context.serverAddress}`, {})
-  t.is(response.data.result, BaseSettings.DEFAULT_CACHE_KEY.default)
-})
-
-test.serial('builds cache key correctly from input params', async (t) => {
-  t.context.adapterEndpoint.inputParameters = {
-    base: {
-      type: 'string',
-      required: true,
-    },
-    quote: {
-      type: 'string',
-      required: false,
-    },
-    factor: {
-      type: 'number',
-      required: true,
-    },
-    proper: {
-      type: 'boolean',
-      required: false,
-    },
-    details: {
-      type: 'object',
-      required: true,
-    },
-    nullable: {
-      type: 'object',
-      required: false,
-    },
-  }
-  const response = await axios.post(`${t.context.serverAddress}`, {
-    data: {
-      base: 'eth',
-      factor: 123,
-      proper: true,
-      details: {
-        asd: 'qwe',
-        zxc: 432,
-      },
-      nullable: null,
-    },
-  })
-  t.is(response.data.result, 'test-|base:eth|factor:123|proper:true|details:')
-})
-
-test.serial('cache key is truncated if over max size', async (t) => {
-  t.context.adapterEndpoint.inputParameters = {
-    base: {
-      type: 'string',
-      required: true,
-    },
-  }
-  const response = await axios.post(`${t.context.serverAddress}`, {
-    data: {
-      base: Array(100)
-        .fill(null)
-        .map((s, i) => `----------${i}`)
-        .join('|'),
-    },
-  })
-  t.is(response.data.result.length, 100 + 1 + 4) // Max common key + separator + endpoint name
-})