@chainlink/external-adapter-framework 0.30.2 → 0.31.0

package/generator-adapter/generators/app/index.js

@@ -0,0 +1,337 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Generator = require("yeoman-generator");
+module.exports = class extends Generator {
+    constructor(args, opts) {
+        super(args, opts);
+        this.endpointsAndAliases = new Set();
+        // When EXTERNAL_ADAPTER_GENERATOR_NO_INTERACTIVE is set to true, the generator will not prompt the user and will use the
+        // default values to create one endpoint with all transports. This is useful for testing the generator in CI, or in cases
+        // where the user wants to quickly generate the boilerplate code.
+        this.promptDisabled = process.env.EXTERNAL_ADAPTER_GENERATOR_NO_INTERACTIVE === 'true';
+        // When EXTERNAL_ADAPTER_GENERATOR_STANDALONE is set to true, tsconfig files (tsconfig.json and tsconfig.test.json) will not
+        // extend tsconfig.base.json which is present in external-adapters-js monorepo, but rather generator will create new tsconfig.base.json
+        // with the same content in the same directory and extend from it. Also, new packages and config files (jest, babel) will be added
+        // to be able to run the tests
+        this.standalone = process.env.EXTERNAL_ADAPTER_GENERATOR_STANDALONE === 'true';
+        this.argument('rootPath', {
+            type: String,
+            required: false,
+            default: './',
+            description: 'Root path where new External Adapter will be created',
+        });
+    }
+    // prompting stage is used to get input from the user, validate and store it to use it for next stages
+    async prompting() {
+        const adapterName = await this._promptAdapterName();
+        const endpointCount = await this._promptEndpointCount();
+        const endpoints = {};
+        for (let i = 0; i < endpointCount; i++) {
+            let inputEndpointName = await this._promptEndpointName(i);
+            this.endpointsAndAliases.add(inputEndpointName);
+            let endpointAliases = await this._promptAliases(inputEndpointName);
+            endpointAliases.forEach(alias => this.endpointsAndAliases.add(alias));
+            const inputTransports = await this._promptTransports(inputEndpointName);
+            endpoints[i] = {
+                inputEndpointName,
+                normalizedEndpointName: this._normalizeEndpointName(inputEndpointName),
+                inputTransports,
+                normalizedEndpointNameCap: '',
+                endpointAliases,
+            };
+            endpoints[i].normalizedEndpointNameCap = endpoints[i].normalizedEndpointName.charAt(0).toUpperCase() + endpoints[i].normalizedEndpointName.slice(1);
+        }
+        const endpointNames = Object.values(endpoints).map(e => e.normalizedEndpointName).join(', ');
+        const includeComments = await this._promptConfirmation(adapterName, endpointNames);
+        this.props = {
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            frameworkVersion: (await Promise.resolve().then(() => require('../../../package.json'))).version,
+            adapterName,
+            endpoints,
+            endpointNames,
+            defaultEndpoint: endpoints[0],
+            includeComments,
+        };
+    }
+    // writing stage is used to create new folder/files with templates based on user-provided input
+    writing() {
+        // Copy base files
+        const baseFiles = [
+            'CHANGELOG.md',
+            'package.json',
+            'README.md',
+            'test-payload.json',
+            'tsconfig.json',
+            'tsconfig.test.json',
+        ];
+        // If the generator is in standalone mode, also create tsconfig.base.json in the same directory
+        // so that both tsconfig and tsconfig.test can extend it. If the generator is not in standalone mode,
+        // tsconfig files will extend base settings from external-adapter-js monorepo base tsconfig.
+        // Same way jest and babel config files are also created to be able to run the integration tests
+        if (this.standalone) {
+            baseFiles.push('tsconfig.base.json', 'babel.config.js', 'jest.config.js');
+        }
+        baseFiles.forEach(fileName => {
+            this.fs.copyTpl(this.templatePath(fileName), this.destinationPath(`${this.options.rootPath}/${this.props.adapterName}/${fileName}`), { ...this.props, standalone: this.standalone });
+        });
+        // copy main index.ts file
+        this.fs.copyTpl(this.templatePath(`src/index.ts.ejs`), this.destinationPath(`${this.options.rootPath}/${this.props.adapterName}/src/index.ts`), this.props);
+        // Copy config
+        this.fs.copy(this.templatePath('src/config/index.ts'), this.destinationPath(`${this.options.rootPath}/${this.props.adapterName}/src/config/index.ts`));
+        this.fs.copyTpl(this.templatePath('src/config/overrides.json'), this.destinationPath(`${this.options.rootPath}/${this.props.adapterName}/src/config/overrides.json`), this.props);
+        // Create endpoint and transport files
+        Object.values(this.props.endpoints).forEach(({ inputEndpointName, inputTransports, endpointAliases }) => {
+            if (inputTransports.length > 1) {
+                // Router endpoints
+                this.fs.copyTpl(this.templatePath('src/endpoint/endpoint-router.ts.ejs'), this.destinationPath(`${this.options.rootPath}/${this.props.adapterName}/src/endpoint/${inputEndpointName}.ts`), {
+                    inputEndpointName,
+                    inputTransports,
+                    endpointAliases,
+                    adapterName: this.props.adapterName,
+                    includeComments: this.props.includeComments,
+                });
+                inputTransports.forEach(transport => {
+                    this.fs.copyTpl(this.templatePath(`src/transport/${transport.type}.ts.ejs`), this.destinationPath(`${this.options.rootPath}/${this.props.adapterName}/src/transport/${inputEndpointName}-${transport.type}.ts`), { inputEndpointName, includeComments: this.props.includeComments });
+                });
+            }
+            else {
+                // Single transport endpoints
+                this.fs.copyTpl(this.templatePath('src/endpoint/endpoint.ts.ejs'), this.destinationPath(`${this.options.rootPath}/${this.props.adapterName}/src/endpoint/${inputEndpointName}.ts`), {
+                    inputEndpointName,
+                    inputTransports,
+                    endpointAliases,
+                    adapterName: this.props.adapterName,
+                    includeComments: this.props.includeComments,
+                });
+                this.fs.copyTpl(this.templatePath(`src/transport/${inputTransports[0].type}.ts.ejs`), this.destinationPath(`${this.options.rootPath}/${this.props.adapterName}/src/transport/${inputEndpointName}.ts`), { inputEndpointName, includeComments: this.props.includeComments });
+            }
+        });
+        // Create endpoint barrel file
+        this.fs.copyTpl(this.templatePath(`src/endpoint/index.ts.ejs`), this.destinationPath(`${this.options.rootPath}/${this.props.adapterName}/src/endpoint/index.ts`), { endpoints: Object.values(this.props.endpoints) });
+        // Create test files
+        const httpEndpoints = Object.values(this.props.endpoints).filter((e) => e.inputTransports.some(t => t.type === 'http'));
+        const wsEndpoints = Object.values(this.props.endpoints).filter((e) => e.inputTransports.some(t => t.type === 'ws'));
+        const customEndpoints = Object.values(this.props.endpoints).filter((e) => e.inputTransports.some(t => t.type === 'custom'));
+        // Create adapter.test.ts if there is at least one endpoint with httpTransport
+        if (httpEndpoints.length) {
+            this.fs.copyTpl(this.templatePath(`test/adapter.test.ts.ejs`), this.destinationPath(`${this.options.rootPath}/${this.props.adapterName}/test/integration/adapter.test.ts`), { endpoints: httpEndpoints, transportName: 'rest' });
+        }
+        // Create adapter.test.ts or adapter-ws.test.ts if there is at least one endpoint with wsTransport
+        if (wsEndpoints.length) {
+            let fileName = 'adapter.test.ts';
+            if (httpEndpoints.length || customEndpoints.length) {
+                fileName = 'adapter-ws.test.ts';
+            }
+            this.fs.copyTpl(this.templatePath(`test/adapter-ws.test.ts.ejs`), this.destinationPath(`${this.options.rootPath}/${this.props.adapterName}/test/integration/${fileName}`), { endpoints: wsEndpoints });
+        }
+        // Create adapter.test.ts or adapter-custom.test.ts if there is at least one endpoint with customTransport.
+        // Custom transport integration tests use the same template as http, but in separate file. This is not ideal
+        // since the setup is the same (usually) and we could have just another test describe block, but at least this is
+        // consistent behavior as each transport-specific test is in its own file.
+        if (customEndpoints.length) {
+            let fileName = 'adapter.test.ts';
+            if (httpEndpoints.length || wsEndpoints.length) {
+                fileName = 'adapter-custom.test.ts';
+            }
+            this.fs.copyTpl(this.templatePath(`test/adapter.test.ts.ejs`), this.destinationPath(`${this.options.rootPath}/${this.props.adapterName}/test/integration/${fileName}`), { endpoints: customEndpoints, transportName: 'custom' });
+        }
+        // Copy test fixtures
+        this.fs.copyTpl(this.templatePath(`test/fixtures.ts.ejs`), this.destinationPath(`${this.options.rootPath}/${this.props.adapterName}/test/integration/fixtures.ts`), {
+            includeWsFixtures: wsEndpoints.length > 0,
+            includeHttpFixtures: httpEndpoints.length > 0 || customEndpoints.length > 0,
+        });
+        // Add dependencies to existing package.json
+        const pkgJson = {
+            devDependencies: {
+                '@types/jest': '27.5.2',
+                '@types/node': '16.11.51',
+                nock: '13.2.9',
+                typescript: '5.0.4',
+            },
+            dependencies: {
+                '@chainlink/external-adapter-framework': this.props.frameworkVersion,
+                tslib: '2.4.1',
+            },
+            scripts: {}
+        };
+        // If EA has websocket transports add additional packages for tests.
+        if (wsEndpoints.length) {
+            pkgJson.devDependencies['@sinonjs/fake-timers'] = '9.1.2';
+            pkgJson.devDependencies['@types/sinonjs__fake-timers'] = '8.1.2';
+        }
+        // If the generator is in standalone mode, add additional packages and a script for running the tests with jest
+        if (this.standalone) {
+            pkgJson.devDependencies['@babel/core'] = '7.21.8';
+            pkgJson.devDependencies['@babel/preset-env'] = '7.20.2';
+            pkgJson.devDependencies['@babel/preset-typescript'] = "7.21.5";
+            pkgJson.devDependencies['jest'] = '29.5.0';
+            pkgJson.scripts['test'] = 'EA_PORT=0 METRICS_ENABLED=false jest --updateSnapshot';
+        }
+        this.fs.extendJSON(this.destinationPath(`${this.options.rootPath}/${this.props.adapterName}/package.json`), pkgJson);
+    }
+    // install stage is used to run npm or yarn install scripts
+    install() {
+        this.yarnInstall([], { cwd: `${this.options.rootPath}/${this.props.adapterName}` });
+    }
+    // end is the last stage. can be used for messages or cleanup
+    end() {
+        this.log(`🚀 Adapter '${this.props.adapterName}' was successfully created. 📍${this.options.rootPath}/${this.props.adapterName}`);
+    }
+    async _promptAdapterName() {
+        if (this.promptDisabled) {
+            return 'example-adapter';
+        }
+        let { adapterName } = await this.prompt({
+            type: 'input',
+            name: 'adapterName',
+            message: 'What is the name of adapter?:',
+            default: 'example-adapter',
+        });
+        adapterName = this._normalizeStringInput(adapterName);
+        if (adapterName === '') {
+            this.log('Adapter name cannot be empty');
+            return this._promptAdapterName();
+        }
+        return adapterName;
+    }
+    async _promptEndpointCount() {
+        if (this.promptDisabled) {
+            return 1;
+        }
+        let { endpointCount } = await this.prompt({
+            type: 'input',
+            name: 'endpointCount',
+            message: 'How many endpoints does adapter have?:',
+            default: '1',
+        });
+        endpointCount = parseInt(endpointCount);
+        if (isNaN(endpointCount) || endpointCount <= 0) {
+            this.log('Adapter should have at least one endpoint');
+            return this._promptEndpointCount();
+        }
+        return endpointCount;
+    }
+    async _promptEndpointName(index) {
+        if (this.promptDisabled) {
+            return 'price';
+        }
+        const { inputEndpointName } = await this.prompt({
+            type: 'input',
+            name: 'inputEndpointName',
+            message: `What is the name of endpoint #${index + 1}:`,
+            default: 'price',
+        });
+        const endpointName = this._normalizeStringInput(inputEndpointName);
+        if (endpointName === '') {
+            this.log('Endpoint name cannot be empty');
+            return this._promptEndpointName(index);
+        }
+        if (this.endpointsAndAliases.has(endpointName)) {
+            this.log(`Endpoint named or aliased '${endpointName}' already exists`);
+            return this._promptEndpointName(index);
+        }
+        return endpointName;
+    }
+    async _promptAliases(inputEndpointName) {
+        if (this.promptDisabled) {
+            return [];
+        }
+        const { endpointAliasesAnswer } = await this.prompt({
+            type: 'input',
+            name: 'endpointAliasesAnswer',
+            message: `Comma separated aliases for endpoint '${inputEndpointName}':`,
+            default: 'empty',
+        });
+        let endpointAliases;
+        if (endpointAliasesAnswer === 'empty' || endpointAliasesAnswer.trim().length === 0) {
+            return [];
+        }
+        else {
+            endpointAliases = [...new Set(...[endpointAliasesAnswer.split(',').map(a => this._normalizeStringInput(a.trim()))])];
+        }
+        let existingEndpoint = endpointAliases.some(a => this.endpointsAndAliases.has(a));
+        if (existingEndpoint) {
+            this.log(`One of endpoints already contains one or more provided aliases.`);
+            return this._promptAliases(inputEndpointName);
+        }
+        return endpointAliases;
+    }
+    async _promptTransports(inputEndpointName) {
+        if (this.promptDisabled) {
+            return [
+                { type: 'http', name: 'httpTransport' }, { type: 'ws', name: 'wsTransport' }, { type: 'custom', name: 'customTransport', }
+            ];
+        }
+        const { inputTransports } = await this.prompt({
+            type: 'checkbox',
+            name: 'inputTransports',
+            message: `Select transports that endpoint '${inputEndpointName}' supports:`,
+            choices: [
+                {
+                    name: 'Http',
+                    value: {
+                        type: 'http',
+                        name: 'httpTransport',
+                    },
+                    checked: true,
+                },
+                {
+                    name: 'Websocket',
+                    value: {
+                        type: 'ws',
+                        name: 'wsTransport',
+                    },
+                },
+                {
+                    name: 'Custom',
+                    value: {
+                        type: 'custom',
+                        name: 'customTransport',
+                    },
+                },
+            ],
+        });
+        if (!inputTransports.length) {
+            this.log('Endpoint should have at least one transport');
+            return this._promptTransports(inputEndpointName);
+        }
+        return inputTransports;
+    }
+    async _promptConfirmation(adapterName, endpointNames) {
+        if (this.promptDisabled) {
+            return true;
+        }
+        const { useComments } = await this.prompt({
+            type: 'confirm',
+            name: 'useComments',
+            default: true,
+            message: `Do you want helpful explicative comments to be included along with the source code? (These are usually not included with adapters but can be helpful if you're new to EA development):`,
+        });
+        const { confirmed } = await this.prompt({
+            type: 'confirm',
+            name: 'confirmed',
+            message: `New adapter '${adapterName}' will be created with following endpoints '${endpointNames}'`,
+        });
+        if (!confirmed) {
+            process.exit(0);
+        }
+        return useComments;
+    }
+    //convert endpoint name to normalized name that can be used in imports/exports, i.e. crypto-one-two -> cryptoOneTwo
+    _normalizeEndpointName(endpointName) {
+        const words = endpointName.split('-');
+        const capitalizedWords = words.map((word, index) => {
+            if (index === 0) {
+                return word;
+            }
+            else {
+                return word.charAt(0).toUpperCase() + word.slice(1);
+            }
+        });
+        return capitalizedWords.join('');
+    }
+    _normalizeStringInput(input) {
+        return input.trim().replace(/ /g, '-');
+    }
+};

package/generator-adapter/generators/app/templates/README.md

@@ -0,0 +1,3 @@
+# Chainlink External Adapter for <%= adapterName %>
+
+This README will be generated automatically when code is merged to `main`. If you would like to generate a preview of the README, please run `yarn generate:readme <%= adapterName %>`.

package/generator-adapter/generators/app/templates/babel.config.js

@@ -0,0 +1,3 @@
+module.exports = {
+  presets: [['@babel/preset-env', { targets: { node: 'current' } }], '@babel/preset-typescript'],
+}

package/generator-adapter/generators/app/templates/jest.config.js

@@ -0,0 +1,3 @@
+module.exports = {
+  modulePathIgnorePatterns: ['./dist'],
+}

package/generator-adapter/generators/app/templates/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@chainlink/<%= adapterName %>-adapter",
+  "version": "0.0.0",
+  "description": "Chainlink <%= adapterName %> adapter.",
+  "keywords": [
+    "Chainlink",
+    "LINK",
+    "blockchain",
+    "oracle",
+    "<%= adapterName %>"
+  ],
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "url": "https://github.com/smartcontractkit/external-adapters-js",
+    "type": "git"
+  },
+  "license": "MIT",
+  "scripts": {
+    "clean": "rm -rf dist && rm -f tsconfig.tsbuildinfo",
+    "prepack": "yarn build",
+    "build": "tsc -b",
+    "server": "node -e 'require(\"./index.js\").server()'",
+    "server:dist": "node -e 'require(\"./dist/index.js\").server()'",
+    "start": "yarn server:dist"
+  }
+}

package/generator-adapter/generators/app/templates/src/config/index.ts

@@ -0,0 +1,25 @@
+import { AdapterConfig } from '@chainlink/external-adapter-framework/config'
+
+export const config = new AdapterConfig(
+  {
+    API_KEY: {
+      description:
+        'An API key for Data Provider',
+      type: 'string',
+      required: true,
+      sensitive: true,
+    },
+    API_ENDPOINT: {
+      description:
+        'An API endpoint for Data Provider',
+      type: 'string',
+      default: 'https://dataproviderapi.com',
+    },
+    WS_API_ENDPOINT: {
+      description:
+        'WS endpoint for Data Provider',
+      type: 'string',
+      default: 'ws://localhost:9090',
+    },
+  },
+)

package/generator-adapter/generators/app/templates/src/config/overrides.json

@@ -0,0 +1,3 @@
+{
+  "<%= adapterName %>": {}
+}

package/generator-adapter/generators/app/templates/src/endpoint/base.ts.ejs

@@ -0,0 +1,21 @@
+<% if (includeComments) { %>// Input parameters define the structure of the request expected by the endpoint.<% } %>
+export const inputParameters = new InputParameters({
+  base: {
+    aliases: ['from', 'coin', 'symbol', 'market'],
+    required: true,
+    type: 'string',
+    description: 'The symbol of symbols of the currency to query',
+  },
+  quote: {
+    aliases: ['to', 'convert'],
+    required: true,
+    type: 'string',
+    description: 'The symbol of the currency to convert to',
+  },
+})
+<% if (includeComments) { %>// Endpoints contain a type parameter that allows specifying relevant types of an endpoint, for example, request payload type, Adapter response type and Adapter configuration (environment variables) type<% } %>
+export type BaseEndpointTypes = {
+  Parameters: typeof inputParameters.definition
+  Response: SingleNumberResultResponse
+  Settings: typeof config.settings
+}

package/generator-adapter/generators/app/templates/src/endpoint/endpoint-router.ts.ejs

@@ -0,0 +1,33 @@
+import { AdapterEndpoint } from '@chainlink/external-adapter-framework/adapter'
+import { InputParameters } from '@chainlink/external-adapter-framework/validation'
+import { SingleNumberResultResponse } from '@chainlink/external-adapter-framework/util'
+import { TransportRoutes } from '@chainlink/external-adapter-framework/transports'
+import { config } from '../config'
+import overrides from '../config/overrides.json'
+<% for(let i=0; i<inputTransports.length; i++) {%>
+import { <%= inputTransports[i].name %> } from '../transport/<%= inputEndpointName %>-<%= inputTransports[i].type %>' <% }
+%>
+
+<%- include ./base.ts.ejs %>
+
+export const endpoint = new AdapterEndpoint({
+<% if (includeComments) { -%>
+  // Endpoint name
+<% } -%><%= ' ' %> name: '<%= inputEndpointName %>',
+<% if (includeComments) { -%>
+  // Alternative endpoint names for this endpoint
+<% } -%><%= ' ' %> aliases: <%- endpointAliases.length ? JSON.stringify(endpointAliases) : JSON.stringify([]) -%>,
+<% if (includeComments) { -%>
+  // Transport handles incoming requests, data processing and communication for this endpoint.
+  // In case endpoint supports multiple transports (i.e. http and websocket) TransportRoutes is used to register all supported transports.
+  // To use specific transport, provide `transport: [transportName]` in the request
+<% } -%><%= ' ' %> transportRoutes: new TransportRoutes<BaseEndpointTypes>()
+<% for(let i=0; i<inputTransports.length; i++) {-%>
+  .register('<%- inputTransports[i].type === "http" ? `rest` : inputTransports[i].type %>', <%- inputTransports[i].name %>)<%}%>,
+<% if (includeComments) { -%>
+  // Supported input parameters for this endpoint
+<% } -%><%= ' ' %> inputParameters,
+<% if (includeComments) { -%>
+  // Overrides are defined in the `/config/overrides.json` file. They allow input parameters to be overriden from a generic symbol to something more specific for the data provider such as an ID.
+<% } -%><%= ' ' %> overrides: overrides['<%= adapterName %>']
+})

package/generator-adapter/generators/app/templates/src/endpoint/endpoint.ts.ejs

@@ -0,0 +1,26 @@
+import { AdapterEndpoint } from '@chainlink/external-adapter-framework/adapter'
+import { InputParameters } from '@chainlink/external-adapter-framework/validation'
+import { SingleNumberResultResponse } from '@chainlink/external-adapter-framework/util'
+import { config } from '../config'
+import overrides from '../config/overrides.json'
+import { <%= inputTransports[0].name %> } from '../transport/<%= inputEndpointName %>'
+
+<%- include ./base.ts.ejs %>
+
+export const endpoint = new AdapterEndpoint({
+<% if (includeComments) { -%>
+  // Endpoint name
+<% } -%><%= ' ' %> name: '<%= inputEndpointName %>',
+<% if (includeComments) { -%>
+  // Alternative endpoint names for this endpoint
+<% } -%><%= ' ' %> aliases: <%- endpointAliases.length ? JSON.stringify(endpointAliases) : JSON.stringify([]) -%>,
+<% if (includeComments) { -%>
+  // Transport handles incoming requests, data processing and communication for this endpoint
+<% } -%><%= ' ' %> transport: <%= inputTransports[0].name %>,
+<% if (includeComments) { -%>
+  // Supported input parameters for this endpoint
+<% } -%><%= ' ' %> inputParameters,
+<% if (includeComments) { -%>
+  // Overrides are defined in the `/config/overrides.json` file. They allow input parameters to be overriden from a generic symbol to something more specific for the data provider such as an ID.
+<% } -%><%= ' ' %> overrides: overrides['<%= adapterName %>']
+})

package/generator-adapter/generators/app/templates/src/endpoint/index.ts.ejs

@@ -0,0 +1 @@
+<% for(let i=0; i<endpoints.length; i++) {%>export { endpoint as <%- endpoints[i].normalizedEndpointName %> } from './<%= endpoints[i].inputEndpointName %>' <%- '\n' %><%}%>

package/generator-adapter/generators/app/templates/src/index.ts.ejs

@@ -0,0 +1,21 @@
+import { expose, ServerInstance } from '@chainlink/external-adapter-framework'
+import { Adapter } from '@chainlink/external-adapter-framework/adapter'
+import { config } from './config'
+import { <%= endpointNames %> } from './endpoint'
+
+export const adapter = new Adapter({
+<% if (includeComments) { -%>
+  //Requests will direct to this endpoint if the `endpoint` input parameter is not specified.
+<% } -%><%= ' ' %> defaultEndpoint: <%= defaultEndpoint.normalizedEndpointName %>.name,
+<% if (includeComments) { -%>
+  // Adapter name
+<% } -%><%= ' ' %> name: '<%= adapterName.toUpperCase() %>',
+<% if (includeComments) { -%>
+  // Adapter configuration (environment variables)
+<% } -%><%= ' ' %> config,
+<% if (includeComments) { -%>
+  // List of supported endpoints
+<% } -%><%= ' ' %> endpoints: [<%= endpointNames %>],
+})
+
+export const server = (): Promise<ServerInstance | undefined> => expose(adapter)

package/generator-adapter/generators/app/templates/src/transport/custom.ts.ejs

@@ -0,0 +1,87 @@
+import { Transport, TransportDependencies } from '@chainlink/external-adapter-framework/transports'
+import { ResponseCache } from '@chainlink/external-adapter-framework/cache/response'
+import { Requester } from '@chainlink/external-adapter-framework/util/requester'
+import {
+  AdapterRequest,
+  AdapterResponse,
+} from '@chainlink/external-adapter-framework/util'
+import { TypeFromDefinition } from '@chainlink/external-adapter-framework/validation/input-params'
+import { BaseEndpointTypes } from '../endpoint/<%= inputEndpointName %>'
+
+<% if (includeComments) { -%>
+// CustomTransport extends base types from endpoint and adds additional, Provider-specific types (if needed).
+<% } -%>
+export type CustomTransportTypes = BaseEndpointTypes & {
+  Provider: {
+    RequestBody: never
+    ResponseBody: any
+  }
+}
+<% if (includeComments) { -%>
+// CustomTransport is used to perform custom data fetching and processing from a Provider. The framework provides built-in transports to
+// fetch data from a Provider using several protocols, including `http`, `websocket`, and `sse`. Use CustomTransport when the Provider uses
+// different protocol, or you need custom functionality that built-in transports don't support. For example, custom, multistep authentication
+// for requests, paginated requests, on-chain data retrieval using third party libraries, and so on.
+<% } -%>
+export class CustomTransport<T extends CustomTransportTypes> implements Transport<T> {
+<% if (includeComments) { -%>
+  // name of the transport, used for logging
+<% } -%>
+  name!: string
+<% if (includeComments) { -%>
+  // cache instance for caching responses from provider
+<% } -%>
+  responseCache!: ResponseCache<T>
+<% if (includeComments) { -%>
+  // instance of Requester to be used for data fetching. Use this instance to perform http calls
+<% } -%>
+  requester!: Requester
+
+<% if (includeComments) { -%>
+  // REQUIRED. Transport will be automatically initialized by the framework using this method. It will be called with transport
+  // dependencies, adapter settings, endpoint name, and transport name as arguments. Use this method to initialize transport state
+<% } -%>
+  async initialize(dependencies: TransportDependencies<T>, _adapterSettings: CustomTransportTypes['Settings'], _endpointName: string, transportName: string): Promise<void> {
+    this.responseCache = dependencies.responseCache
+    this.requester = dependencies.requester
+    this.name = transportName
+  }
+<% if (includeComments) { -%>
+  // 'foregroundExecute' performs synchronous fetch/processing of information within the lifecycle of an incoming request. It takes
+  // request object (adapter request, which is wrapper around fastify request) and adapter settings. Use this method to handle the incoming
+  // request, process it,save it in the cache and return to user.
+<% } -%>
+  async foregroundExecute(
+    req: AdapterRequest<TypeFromDefinition<T['Parameters']>>,
+  ): Promise<AdapterResponse<CustomTransportTypes['Response']>> {
+
+    // Custom transport logic
+
+    const response = {
+      data: {
+        result: 100,
+      },
+      statusCode: 200,
+      result: 100,
+      timestamps: {
+        providerDataRequestedUnixMs: Date.now(),
+        providerDataReceivedUnixMs: Date.now(),
+        providerIndicatedTimeUnixMs: undefined,
+      },
+    }
+<% if (includeComments) { -%>
+    // Once the response object is ready, write it to the cache. Use the transport name, request payload and constructed response. Once cache is
+    // saved, return the response to the user.
+<% } -%>
+    await this.responseCache.write(this.name, [
+      {
+        params: req.requestContext.data,
+        response,
+      },
+    ])
+
+    return response
+  }
+}
+
+export const customTransport = new CustomTransport()