@chainlink/external-adapter-framework 0.30.1 → 0.30.3

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()

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

@@ -0,0 +1,98 @@
+import { HttpTransport } from '@chainlink/external-adapter-framework/transports'
+import { BaseEndpointTypes } from '../endpoint/<%= inputEndpointName %>'
+
+export interface ResponseSchema {
+  [key: string]: {
+    price: number
+    errorMessage?: string
+  }
+}
+
+<% if (includeComments) { -%>
+// HttpTransport extends base types from endpoint and adds additional, Provider-specific types like 'RequestBody', which is the type of
+// request body (not the request to adapter, but the request that adapter sends to Data Provider), and 'ResponseBody' which is
+// the type of raw response from Data Provider
+<% } -%>
+export type HttpTransportTypes = BaseEndpointTypes & {
+  Provider: {
+    RequestBody: never
+    ResponseBody: ResponseSchema
+  }
+}
+<% if (includeComments) { -%>
+// HttpTransport is used to fetch and process data from a Provider using HTTP(S) protocol. It usually needs two methods
+// `prepareRequests` and `parseResponse`
+<% } -%>
+export const httpTransport = new HttpTransport<HttpTransportTypes>({
+<% if (includeComments) { -%>
+  // `prepareRequests` method receives request payloads sent to associated endpoint alongside adapter config(environment variables)
+  // and should return 'request information' to the Data Provider. Use this method to construct one or many requests, and the framework
+  // will send them to Data Provider
+<% } -%>
+  prepareRequests: (params, config) => {
+    return params.map((param) => {
+      return {
+<% if (includeComments) { -%>
+        // `params` are parameters associated to this single request and will also be available in the 'parseResponse' method.
+<% } -%>
+        params: [param],
+<% if (includeComments) { -%>
+        // `request` contains any valid axios request configuration
+<% } -%>
+        request: {
+          baseURL: config.API_ENDPOINT,
+          url: '/cryptocurrency/price',
+          headers: {
+            'X_API_KEY': config.API_KEY,
+          },
+          params: {
+            symbol: param.base.toUpperCase(),
+            convert: param.quote.toUpperCase(),
+          },
+        },
+      }
+    })
+  },
+<% if (includeComments) { -%>
+  // `parseResponse` takes the 'params' specified in the `prepareRequests` and the 'response' from Data Provider and should return
+  // an array of response objects to be stored in cache. Use this method to construct a list of response objects for every parameter in 'params'
+  // and the framework will save them in cache and return to user
+<% } -%>
+  parseResponse: (params, response) => {
+<% if (includeComments) { -%>
+    // In case error was received, it's a good practice to return meaningful information to user
+<% } -%>
+    if (!response.data) {
+      return params.map((param) => {
+        return {
+          params: param,
+          response: {
+            errorMessage: `The data provider didn't return any value for ${param.base}/${param.quote}`,
+            statusCode: 502,
+          },
+        }
+      })
+    }
+
+<% if (includeComments) { -%>
+    // For successful responses for each 'param' a new response object is created and returned as an array
+<% } -%>
+    return params.map((param) => {
+      const result = response.data[param.base.toUpperCase()].price
+<% if (includeComments) { -%>
+      // Response objects, whether successful or errors, contain two properties, 'params' and 'response'. 'response' is what will be
+      // stored in the cache and returned as adapter response and 'params' determines the identifier so that the next request with same 'params'
+      // will immediately return the response from the cache
+<% } -%>
+      return {
+        params: param,
+        response: {
+          result,
+          data: {
+            result
+          }
+        },
+      }
+    })
+  },
+})

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

@@ -0,0 +1,94 @@
+import { WebSocketTransport } from '@chainlink/external-adapter-framework/transports'
+import { BaseEndpointTypes } from '../endpoint/<%= inputEndpointName %>'
+
+export interface WSResponse {
+  success: boolean
+  price: number
+  base: string
+  quote: string
+  time: number
+}
+
+<% if (includeComments) { -%>
+// WsTransport extends base types from endpoint and adds additional, Provider-specific types like 'WsMessage', which is the type of
+// websocket received message
+<% } -%>
+export type WsTransportTypes = BaseEndpointTypes & {
+  Provider: {
+    WsMessage: WSResponse
+  }
+}
+<% if (includeComments) { -%>
+// WebSocketTransport is used to fetch and process data from a Provider using Websocket protocol.
+<% } -%>
+export const wsTransport = new WebSocketTransport<WsTransportTypes>({
+<% if (includeComments) { -%>
+  // use `url` method to provide connection url. It accepts adapter context, so you have access to adapter config(environment variables) and
+  // request payload if needed
+<% } -%>
+  url: (context) => context.adapterSettings.WS_API_ENDPOINT,
+<% if (includeComments) { -%>
+  // 'handler' contains two helpful methods. one of them is `message`. This method is called when there is a new websocket message.
+  // The other one is 'open' method. It is called when the websocket connection is successfully opened. Use this method to execute some logic
+  // when the connection is established (custom authentication, logging, ...)
+<% } -%>
+  handlers: {
+<% if (includeComments) { -%>
+    // 'message' handler receives a raw websocket message as first argument and adapter context as second and should return an array of
+    // response objects. Use this method to construct a list of response objects, and the framework will save them in cache and return to user
+<% } -%>
+    message(message) {
+<% if (includeComments) { -%>
+      // in cases when error or unknown message is received, use 'return' to skip the iteration.
+<% } -%>
+      if (message.success === false) {
+        return
+      }
+
+<% if (includeComments) { -%>
+    // Response objects, whether successful or errors (if not skipped), contain two properties, 'params' and 'response'. 'response' is what
+    // will be stored in the cache and returned as adapter response and 'params' determines the identifier so that the next request with
+    // same 'params' will immediately return the response from the cache
+<% } -%>
+      return [
+        {
+          params: { base: message.base, quote: message.quote },
+          response: {
+            result: message.price,
+            data: {
+             result: message.price
+            },
+            timestamps: {
+              providerIndicatedTimeUnixMs: message.time,
+            },
+          },
+        },
+      ]
+    },
+  },
+<% if (includeComments) { -%>
+  // `builders` are builder methods, that will be used to prepare specific WS messages to be sent to Data Provider
+<% } -%>
+  builders: {
+<% if (includeComments) { -%>
+    // `subscribeMessage` accepts request parameters and should construct and return a payload that will be sent to Data Provider
+    // Use this method to subscribe to live feeds
+<% } -%>
+    subscribeMessage: (params) => {
+      return {
+        type: 'subscribe',
+        symbols: `${params.base}/${params.quote}`.toUpperCase()
+      }
+    },
+<% if (includeComments) { -%>
+    // `unsubscribeMessage` accepts request parameters and should construct and return a payload that will be sent to Data Provider
+    // Use this method to unsubscribe from live feeds
+<% } -%>
+    unsubscribeMessage: (params) => {
+      return {
+        type: 'unsubscribe',
+        symbols: `${params.base}/${params.quote}`.toUpperCase()
+      }
+    },
+  },
+})

package/generator-adapter/generators/app/templates/test/adapter-ws.test.ts.ejs

@@ -0,0 +1,58 @@
+import { WebSocketClassProvider } from '@chainlink/external-adapter-framework/transports'
+import {
+  TestAdapter,
+  setEnvVariables,
+  mockWebSocketProvider,
+  MockWebsocketServer,
+} from '@chainlink/external-adapter-framework/util/testing-utils'
+import FakeTimers from '@sinonjs/fake-timers'
+import { mockWebsocketServer } from './fixtures'
+
+
+describe('websocket', () => {
+  let mockWsServer: MockWebsocketServer | undefined
+  let testAdapter: TestAdapter
+  const wsEndpoint = 'ws://localhost:9090'
+  let oldEnv: NodeJS.ProcessEnv
+<% for(let i=0; i<endpoints.length; i++) {%>
+  const data<%- endpoints[i].normalizedEndpointNameCap %> = {
+    base: 'ETH',
+    quote: 'USD',
+    endpoint: '<%- endpoints[i].inputEndpointName %>',
+    transport: 'ws'
+  }
+<% } %>
+  beforeAll(async () => {
+    oldEnv = JSON.parse(JSON.stringify(process.env))
+    process.env['WS_API_ENDPOINT'] = wsEndpoint
+    process.env['API_KEY'] = 'fake-api-key'
+    mockWebSocketProvider(WebSocketClassProvider)
+    mockWsServer = mockWebsocketServer(wsEndpoint)
+
+    const adapter = (await import('./../../src')).adapter
+    testAdapter = await TestAdapter.startWithMockedCache(adapter, {
+      clock: FakeTimers.install(),
+      testAdapter: {} as TestAdapter<never>,
+    })
+
+    // Send initial request to start background execute and wait for cache to be filled with results
+<% for(var i=0; i<endpoints.length; i++) {%>
+    await testAdapter.request(data<%- endpoints[i].normalizedEndpointNameCap %>) <% } %>
+    await testAdapter.waitForCache(<%- endpoints.length %>)
+  })
+
+  afterAll(async () => {
+    setEnvVariables(oldEnv)
+    mockWsServer?.close()
+    testAdapter.clock?.uninstall()
+    await testAdapter.api.close()
+  })
+<% for(var i=0; i<endpoints.length; i++) {%>
+  describe('<%= endpoints[i].inputEndpointName %> endpoint', () => {
+    it('should return success', async () => {
+      const response = await testAdapter.request(data<%- endpoints[i].normalizedEndpointNameCap %>)
+      expect(response.json()).toMatchSnapshot()
+    })
+  })
+<% } %>
+})

package/generator-adapter/generators/app/templates/test/adapter.test.ts.ejs

@@ -0,0 +1,50 @@
+import {
+  TestAdapter,
+  setEnvVariables,
+} from '@chainlink/external-adapter-framework/util/testing-utils'
+import * as nock from 'nock'
+import { mockResponseSuccess } from './fixtures'
+
+describe('execute', () => {
+  let spy: jest.SpyInstance
+  let testAdapter: TestAdapter
+  let oldEnv: NodeJS.ProcessEnv
+
+  beforeAll(async () => {
+    oldEnv = JSON.parse(JSON.stringify(process.env))
+    process.env.API_KEY = process.env.API_KEY ?? 'fake-api-key'
+    const mockDate = new Date('2001-01-01T11:11:11.111Z')
+    spy = jest.spyOn(Date, 'now').mockReturnValue(mockDate.getTime())
+
+    const adapter = (await import('./../../src')).adapter
+    adapter.rateLimiting = undefined
+    testAdapter = await TestAdapter.startWithMockedCache(adapter, {
+      testAdapter: {} as TestAdapter<never>,
+    })
+  })
+
+  afterAll(async () => {
+    setEnvVariables(oldEnv)
+    await testAdapter.api.close()
+    nock.restore()
+    nock.cleanAll()
+    spy.mockRestore()
+  })
+
+  <% for(var i=0; i<endpoints.length; i++) {%>
+  describe('<%= endpoints[i].inputEndpointName %> endpoint', () => {
+    it('should return success', async () => {
+      const data = {
+        base: 'ETH',
+        quote: 'USD',
+        endpoint: '<%= endpoints[i].inputEndpointName %>',
+        transport: '<%= transportName %>'
+      }
+      mockResponseSuccess()
+      const response = await testAdapter.request(data)
+      expect(response.statusCode).toBe(200)
+      expect(response.json()).toMatchSnapshot()
+    })
+  })
+      <% } %>
+})

package/generator-adapter/generators/app/templates/test/fixtures.ts.ejs

@@ -0,0 +1,44 @@
+<% if (includeHttpFixtures) { %>import nock from 'nock'<% } %>
+<% if (includeWsFixtures) { %>import { MockWebsocketServer } from '@chainlink/external-adapter-framework/util/testing-utils'<% } %>
+<% if (includeHttpFixtures) { %>
+export const mockResponseSuccess = (): nock.Scope =>
+    nock('https://dataproviderapi.com', {
+      encodedQueryParams: true,
+    })
+      .get('/cryptocurrency/price')
+      .query({
+        symbol: 'ETH',
+        convert: 'USD',
+      })
+      .reply(200, () => ({ ETH: { price: 10000 } }), [
+        'Content-Type',
+        'application/json',
+        'Connection',
+        'close',
+        'Vary',
+        'Accept-Encoding',
+        'Vary',
+        'Origin',
+      ])
+      .persist()
+<% } %>
+<% if (includeWsFixtures) { %>
+export const mockWebsocketServer = (URL: string): MockWebsocketServer => {
+    const mockWsServer = new MockWebsocketServer(URL, { mock: false })
+    mockWsServer.on('connection', (socket) => {
+      socket.on('message', (message) => {
+          return socket.send(
+            JSON.stringify({
+              success: true,
+              price: 1000,
+              base: 'ETH',
+              quote: 'USD',
+              time: '1999999'
+            }),
+          )
+      })
+    })
+
+    return mockWsServer
+  }
+<% } %>

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

@@ -0,0 +1,6 @@
+{
+ "requests": [{
+  "from": "BTC",
+  "to": "USD"
+ }]
+}

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

@@ -0,0 +1,40 @@
+{
+  "compilerOptions": {
+    /* Basic Options */
+    "incremental": true /* Enable incremental compilation */,
+    "target": "ES2020" /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019' or 'ESNEXT'. */,
+    "module": "commonjs" /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', or 'ESNext'. */,
+    "composite": true /* Enable project compilation */,
+    "declaration": true /* Generates corresponding '.d.ts' file. */,
+    "declarationMap": true /* Generates a sourcemap for each corresponding '.d.ts' file. */,
+    "noEmit": false /* Do not emit outputs. */,
+    "noErrorTruncation": true /* Do not truncate error messages */,
+    "skipLibCheck": true /* Skip type checking of declaration files. Requires TypeScript version 2.0 or later. */,
+    "importHelpers": true /* Import emit helpers from 'tslib'. */,
+
+    /* Strict Type-Checking Options */
+    "strict": true /* Enable all strict type-checking options. */,
+
+    /* Additional Checks */
+    "noUnusedLocals": true /* Report errors on unused locals. */,
+    "noUnusedParameters": true /* Report errors on unused parameters. */,
+    "noImplicitReturns": true /* Report error when not all code paths in function return a value. */,
+    "noFallthroughCasesInSwitch": true /* Report errors for fallthrough cases in switch statement. */,
+    "forceConsistentCasingInFileNames": true /* Disallow inconsistently-cased references to the same file. */,
+
+    /* Module Resolution Options */
+    "moduleResolution": "node" /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */,
+    "allowSyntheticDefaultImports": true /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */,
+    "esModuleInterop": true /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */,
+
+    /* Source Map Options */
+    "inlineSourceMap": true /* Emit a single file with source maps instead of having a separate file. */,
+    "inlineSources": true /* Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set. */,
+
+    /* Experimental Options */
+    "experimentalDecorators": true /* Enables experimental support for ES7 decorators. */,
+    "emitDecoratorMetadata": true /* Enables experimental support for emitting type metadata for decorators. */,
+
+    "resolveJsonModule": true /* Allows importing modules with a ‘.json’ extension */
+  }
+}

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

@@ -0,0 +1,9 @@
+{
+  "extends": "<%- standalone ? "./tsconfig.base.json" : "../../tsconfig.base.json" %>",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src/**/*", "src/**/*.json"],
+  "exclude": ["dist", "**/*.spec.ts", "**/*.test.ts"]
+}