fix(style): lint changes

packages/api/jest.config.js

@@ -6,6 +6,6 @@ module.exports = {
   moduleNameMapper: {
     // See https://stackoverflow.com/a/73203803
     // Force module uuid to resolve with the CJS entry point, because Jest does not support package.json.exports. See https://github.com/uuidjs/uuid/issues/451
-    uuid: require.resolve('uuid')
-  }
+    uuid: require.resolve('uuid'),
+  },
 }

packages/api/migrate-mongo-config.js

@@ -3,12 +3,12 @@ require('dotenv/config')
 const config = {
   mongodb: {
     url: process.env.MONGO_URI,
-    databaseName: process.env.MONGO_INITDB_DATABASE
+    databaseName: process.env.MONGO_INITDB_DATABASE,
   },
   migrationsDir: 'migrations',
   changelogCollectionName: 'changelog',
   migrationFileExtension: '.js',
-  useFileHash: false
+  useFileHash: false,
 }
 
 module.exports = config

packages/api/migrations/1_rename-boba-networks.js

@@ -1,21 +1,21 @@
 module.exports = {
-  async up (db) {
+  async up(db) {
     const resultRequestCollection = db.collection('result_request')
     await Promise.all(
       (await resultRequestCollection.find({ feedFullName: /boba-/ }).toArray())
-        .map(resultRequest => ({
+        .map((resultRequest) => ({
           ...resultRequest,
           feedFullName: resultRequest.feedFullName.replace(
             /boba-/,
-            'boba-ethereum-'
-          )
+            'boba-ethereum-',
+          ),
         }))
-        .map(resultRequest =>
+        .map((resultRequest) =>
           resultRequestCollection.updateOne(
             { _id: resultRequest._id },
-            { $set: { feedFullName: resultRequest.feedFullName } }
-          )
-        )
+            { $set: { feedFullName: resultRequest.feedFullName } },
+          ),
+        ),
     )
-  }
+  },
 }

packages/api/migrations/2_rename-conflux-networks.js

@@ -1,44 +1,44 @@
 module.exports = {
-  async up (db) {
+  async up(db) {
     const resultRequestCollection = db.collection('result_request')
     const updateConfluxTethysPromises = (
       await resultRequestCollection
         .find({ feedFullName: /conflux-tethys/ })
         .toArray()
     )
-      .map(resultRequest => ({
+      .map((resultRequest) => ({
         ...resultRequest,
         feedFullName: resultRequest.feedFullName.replace(
           /conflux-tethys/,
-          'conflux-core-mainnet'
-        )
+          'conflux-core-mainnet',
+        ),
       }))
-      .map(resultRequest =>
+      .map((resultRequest) =>
         resultRequestCollection.updateOne(
           { _id: resultRequest._id },
-          { $set: { feedFullName: resultRequest.feedFullName } }
-        )
+          { $set: { feedFullName: resultRequest.feedFullName } },
+        ),
       )
     const updateConfluxRinkebyPromises = (
       await resultRequestCollection.find({
-        feedFullName: /conflux-testnet/
+        feedFullName: /conflux-testnet/,
       })
     )
-      .map(resultRequest => ({
+      .map((resultRequest) => ({
         ...resultRequest,
         feedFullName: resultRequest.feedFullName.replace(
           /conflux-testnet/,
-          'conflux-core-testnet'
-        )
+          'conflux-core-testnet',
+        ),
       }))
-      .map(resultRequest =>
+      .map((resultRequest) =>
         resultRequestCollection.updateOne(
           { _id: resultRequest._id },
-          { $set: { feedFullName: resultRequest.feedFullName } }
-        )
+          { $set: { feedFullName: resultRequest.feedFullName } },
+        ),
       )
     await Promise.all(
-      [updateConfluxTethysPromises, updateConfluxRinkebyPromises].flat()
+      [updateConfluxTethysPromises, updateConfluxRinkebyPromises].flat(),
     )
-  }
+  },
 }

packages/api/readme.md

@@ -1 +1 @@
-# Data Feeds Explorer Api 
+# Data Feeds Explorer Api

packages/api/src/database.ts

@@ -5,12 +5,12 @@ export class MongoManager {
   db: Db
   client: MongoClient
 
-  async start (uri?: string): Promise<Db | null> {
+  async start(uri?: string): Promise<Db | null> {
     const mongoDbUri = uri || process.env.MONGO_URI
     return this.connect(mongoDbUri, process.env.MONGO_INITDB_DATABASE as string)
   }
 
-  async connect (uri: string, name: string): Promise<Db | null> {
+  async connect(uri: string, name: string): Promise<Db | null> {
     this.client = new MongoClient(uri)
 
     try {
@@ -23,11 +23,11 @@ export class MongoManager {
     return null
   }
 
-  async stop (): Promise<void> {
+  async stop(): Promise<void> {
     await this.client.close()
   }
 
-  async drop (): Promise<void> {
+  async drop(): Promise<void> {
     const collections = await this.db.collections()
     for (const collection of collections) {
       await this.db.dropCollection(collection.collectionName)

packages/api/src/fetchSvgs.ts

@@ -8,18 +8,18 @@ const STATIC_LOGOS_SVG_URL = process.env.TEST_BRANCH
   ? `https://raw.githubusercontent.com/witnet/data-feeds-explorer//${process.env.TEST_BRANCH}/packages/ui/assets/svg/`
   : 'https://raw.githubusercontent.com/witnet/data-feeds-explorer/main/packages/ui/assets/svg/'
 
-export async function fetchSvgs (
-  networksToFetch: Array<string>
+export async function fetchSvgs(
+  networksToFetch: Array<string>,
 ): Promise<{ [key: string]: string }> {
   const networksWithoutRepeated = removeRepeatedElements(networksToFetch)
   const logosUrls = networksWithoutRepeated.map(
-    (networkToFetch: string) => `${STATIC_LOGOS_SVG_URL}${networkToFetch}.svg`
+    (networkToFetch: string) => `${STATIC_LOGOS_SVG_URL}${networkToFetch}.svg`,
   )
 
   // Fetch all logos from github
-  const promises = logosUrls.map(url => axios.get(url))
-  return new Promise(resolve => {
-    Promise.allSettled(promises).then(results => {
+  const promises = logosUrls.map((url) => axios.get(url))
+  return new Promise((resolve) => {
+    Promise.allSettled(promises).then((results) => {
       const svgs = results.map((result, index) => {
         if (result.status === 'rejected') {
           console.log(`Error fetching logo from: ${logosUrls[index]}`)
@@ -32,9 +32,9 @@ export async function fetchSvgs (
       const svgByName = networksWithoutRepeated.reduce(
         (acc, val, index) => ({
           ...acc,
-          [val]: svgs[index]
+          [val]: svgs[index],
         }),
-        {}
+        {},
       )
 
       resolve(svgByName)

packages/api/src/index.ts

@@ -5,58 +5,65 @@ import { MongoManager } from './database'
 import { FeedRepository } from './repository/Feed'
 import { ResultRequestRepository } from './repository/ResultRequest'
 import { createServer } from './server'
-import {  RouterDataFeedsConfig, Repositories, FeedInfo, NetworksConfig } from './types'
+import {
+  RouterDataFeedsConfig,
+  Repositories,
+  FeedInfo,
+  NetworksConfig,
+} from './types'
 import { Web3Middleware } from './web3Middleware/index'
 import { normalizeNetworkConfig } from './utils/index'
 import {
   normalizeAndValidateDataFeedConfig,
-  fetchDataFeedsRouterConfig
+  fetchDataFeedsRouterConfig,
 } from './readDataFeeds'
 import { SvgCache } from './svgCache'
 import { NetworkRouter } from './web3Middleware/NetworkRouter'
 import { Configuration } from './web3Middleware/Configuration'
 
-async function main () {
+async function main() {
   const svgCache = new SvgCache()
   const mongoManager = new MongoManager()
   const db = await mongoManager.start()
-  const configurationFile: RouterDataFeedsConfig = await fetchDataFeedsRouterConfig()
+  const configurationFile: RouterDataFeedsConfig =
+    await fetchDataFeedsRouterConfig()
   const configuration = new Configuration(configurationFile)
 
-  const legacyFeeds: Array<FeedInfo> = normalizeAndValidateDataFeedConfig(configurationFile)
-  const networksConfigPartial: Array<Omit<
-    NetworksConfig,
-    'logo'
-  >> = normalizeNetworkConfig(configurationFile)
+  const legacyFeeds: Array<FeedInfo> =
+    normalizeAndValidateDataFeedConfig(configurationFile)
+  const networksConfigPartial: Array<Omit<NetworksConfig, 'logo'>> =
+    normalizeNetworkConfig(configurationFile)
 
   const logosToFetch = networksConfigPartial.map(
     (networksConfig: NetworksConfig) => {
       return networksConfig.chain.toLowerCase()
-    }
+    },
   )
 
-  const networksLogos: { [key: string]: string } = await svgCache.getMany(
-    logosToFetch
-  )
+  const networksLogos: { [key: string]: string } =
+    await svgCache.getMany(logosToFetch)
 
   const networksConfig = networksConfigPartial.map((networksConfig, index) => ({
     ...networksConfig,
-    logo: networksLogos[logosToFetch[index]]
+    logo: networksLogos[logosToFetch[index]],
   }))
 
-  const routers = configuration.listNetworksUsingPriceFeedsContract()
-    .filter(config => {
+  const routers = configuration
+    .listNetworksUsingPriceFeedsContract()
+    .filter((config) => {
       if (!config.provider) {
-        console.warn("No provider found for ", config.key)
+        console.warn('No provider found for ', config.key)
       }
       return config.provider
     })
-    .map(networkInfo => new NetworkRouter(configuration, repositories, networkInfo))
-
+    .map(
+      (networkInfo) =>
+        new NetworkRouter(configuration, repositories, networkInfo),
+    )
 
   const newFeeds: Array<FeedInfo> = []
 
-  for (let router of routers) {
+  for (const router of routers) {
     const feedInfos = await router.getFeedInfos()
     newFeeds.concat(feedInfos)
   }
@@ -65,7 +72,7 @@ async function main () {
 
   const repositories: Repositories = {
     feedRepository: new FeedRepository(feeds),
-    resultRequestRepository: new ResultRequestRepository(db, feeds)
+    resultRequestRepository: new ResultRequestRepository(db, feeds),
   }
 
   const web3Middleware = new Web3Middleware(
@@ -78,7 +85,7 @@ async function main () {
 
   await createServer(repositories, svgCache, {
     dataFeedsConfig: feeds,
-    networksConfig
+    networksConfig,
   })
 }
 

packages/api/src/loaders/index.ts

@@ -3,26 +3,26 @@ import { SvgCache } from '../svgCache'
 import {
   Loaders,
   Repositories,
-  ResultRequestDbObjectNormalized
+  ResultRequestDbObjectNormalized,
 } from '../types'
 
 export class LoadersFactory {
   repositories: Repositories
   svgCache: SvgCache
 
-  constructor (repositories: Repositories, svgCache: SvgCache) {
+  constructor(repositories: Repositories, svgCache: SvgCache) {
     this.repositories = repositories
     this.svgCache = svgCache
   }
   // returns a loader that fetches data using the given function
-  private genericLoader<T> (load: (filter) => T) {
+  private genericLoader<T>(load: (filter) => T) {
     return new DataLoader(async (filters: Array<string>) => {
       // load data from all
       const data = await Promise.all(
         await filters.map(async (filter, index) => ({
           data: await load(filter),
-          index
-        }))
+          index,
+        })),
       )
       // ensure they are sorted
       const fetchedDataByIndex = data.reduce((acc, val) => {
@@ -34,13 +34,13 @@ export class LoadersFactory {
     })
   }
 
-  getLoaders (): Loaders {
+  getLoaders(): Loaders {
     return {
       lastResult: this.genericLoader<Promise<ResultRequestDbObjectNormalized>>(
         async (feedFullName: string) =>
           await this.repositories.resultRequestRepository.getLastResult(
-            feedFullName
-          )
+            feedFullName,
+          ),
       ),
 
       requests: this.genericLoader<
@@ -53,15 +53,15 @@ export class LoadersFactory {
         if (filter.timestamp.toString().length !== 10) {
           // invalid timestamp
           console.log(
-            '[requests] invalid timestamp argument -> returning last 7 days'
+            '[requests] invalid timestamp argument -> returning last 7 days',
           )
           timestamp = dateNow - sevenDaysInSeconds
         }
 
         if (dateNow < filter.timestamp) {
           // received timestamp is greater than current time
           console.log(
-            '[requests] invalid timestamp argument -> returning last 7 days'
+            '[requests] invalid timestamp argument -> returning last 7 days',
           )
           timestamp = dateNow - sevenDaysInSeconds
         }
@@ -74,12 +74,12 @@ export class LoadersFactory {
 
         return await this.repositories.resultRequestRepository.getFeedRequests(
           filter.feedFullName,
-          timestamp
+          timestamp,
         )
       }),
       logos: new DataLoader(async (logos: Array<string>) => {
         return Object.values(await this.svgCache.getMany(logos))
-      })
+      }),
     }
   }
 }