@graphprotocol/graph-cli 0.37.2 → 0.37.3-alpha-20230110163550-d64bef6

package/src/command-helpers/abi.js

@@ -1,6 +1,6 @@
-const { withSpinner } = require('./spinner')
-const fetch = require('node-fetch')
-const immutable = require('immutable')
+import { withSpinner } from './spinner'
+import fetch from 'node-fetch'
+import immutable from 'immutable'
 
 const loadAbiFromEtherscan = async (ABI, network, address) =>
   await withSpinner(
@@ -8,7 +8,7 @@ const loadAbiFromEtherscan = async (ABI, network, address) =>
     `Failed to fetch ABI from Etherscan`,
     `Warnings while fetching ABI from Etherscan`,
     async spinner => {
-      const scanApiUrl = getEtherscanLikeAPIUrl(network);
+      const scanApiUrl = getEtherscanLikeAPIUrl(network)
       let result = await fetch(
         `${scanApiUrl}?module=contract&action=getabi&address=${address}`,
       )
@@ -32,9 +32,10 @@ const loadAbiFromBlockScout = async (ABI, network, address) =>
     `Warnings while fetching ABI from BlockScout`,
     async spinner => {
       let result = await fetch(
-        `https://blockscout.com/${
-          network.replace('-', '/')
-        }/api?module=contract&action=getabi&address=${address}`,
+        `https://blockscout.com/${network.replace(
+          '-',
+          '/',
+        )}/api?module=contract&action=getabi&address=${address}`,
       )
       let json = await result.json()
 
@@ -49,30 +50,45 @@ const loadAbiFromBlockScout = async (ABI, network, address) =>
     },
   )
 
-const getEtherscanLikeAPIUrl = (network) => {
+const getEtherscanLikeAPIUrl = network => {
   switch (network) {
-    case "mainnet": return `https://api.etherscan.io/api`
-    case "arbitrum-one": return `https://api.arbiscan.io/api`
-    case "bsc": return `https://api.bscscan.com/api`
-    case "matic": return `https://api.polygonscan.com/api`
-    case "mumbai": return `https://api-testnet.polygonscan.com/api`
-    case "aurora": return `https://api.aurorascan.dev/api`
-    case "aurora-testnet": return `https://api-testnet.aurorascan.dev/api`
-    case "optimism-kovan": return `https://api-kovan-optimistic.etherscan.io/api`
-    case "optimism": return `https://api-optimistic.etherscan.io/api`
-    case "moonbeam": return `https://api-moonbeam.moonscan.io/api`
-    case "moonriver": return `https://api-moonriver.moonscan.io/api`
-    case "mbase": return `https://api-moonbase.moonscan.io/api`
-    case "avalanche": return `https://api.snowtrace.io/api`;
-    case "fuji": return `https://api-testnet.snowtrace.io/api`;
-    case "gnosis": return `https://api.gnosisscan.io/api`;
-    case "fantom": return `https://api.ftmscan.com/api`;
-    case "fantom-testnet": return `https://api-testnet.ftmscan.com/api`;
-    default: return `https://api-${network}.etherscan.io/api`
+    case 'mainnet':
+      return `https://api.etherscan.io/api`
+    case 'arbitrum-one':
+      return `https://api.arbiscan.io/api`
+    case 'bsc':
+      return `https://api.bscscan.com/api`
+    case 'matic':
+      return `https://api.polygonscan.com/api`
+    case 'mumbai':
+      return `https://api-testnet.polygonscan.com/api`
+    case 'aurora':
+      return `https://api.aurorascan.dev/api`
+    case 'aurora-testnet':
+      return `https://api-testnet.aurorascan.dev/api`
+    case 'optimism-kovan':
+      return `https://api-kovan-optimistic.etherscan.io/api`
+    case 'optimism':
+      return `https://api-optimistic.etherscan.io/api`
+    case 'moonbeam':
+      return `https://api-moonbeam.moonscan.io/api`
+    case 'moonriver':
+      return `https://api-moonriver.moonscan.io/api`
+    case 'mbase':
+      return `https://api-moonbase.moonscan.io/api`
+    case 'avalanche':
+      return `https://api.snowtrace.io/api`
+    case 'fuji':
+      return `https://api-testnet.snowtrace.io/api`
+    case 'gnosis':
+      return `https://api.gnosisscan.io/api`
+    case 'fantom':
+      return `https://api.ftmscan.com/api`
+    case 'fantom-testnet':
+      return `https://api-testnet.ftmscan.com/api`
+    default:
+      return `https://api-${network}.etherscan.io/api`
   }
 }
 
-module.exports = {
-  loadAbiFromEtherscan,
-  loadAbiFromBlockScout,
-}
+export { loadAbiFromEtherscan, loadAbiFromBlockScout }

package/src/command-helpers/auth.js

@@ -1,8 +1,8 @@
-const toolbox = require('gluegun/toolbox')
-const { normalizeNodeUrl } = require('./node')
+import * as toolbox from 'gluegun/toolbox'
+import { normalizeNodeUrl } from './node'
 
-const fs = require('fs')
-const path = require('path')
+import fs from 'fs'
+import path from 'path'
 const homedir = require('os').homedir()
 
 const CONFIG_PATH = path.join(homedir, '/.graph-cli.json')
@@ -14,7 +14,7 @@ const getConfig = () => {
     config = {}
   }
   return config
- }
+}
 
 const identifyDeployKey = async (node, deployKey) => {
   // Determine the deploy key to use, if any:
@@ -45,7 +45,4 @@ const saveDeployKey = async (node, deployKey) => {
   }
 }
 
-module.exports = {
-  identifyDeployKey,
-  saveDeployKey,
-}
+export { identifyDeployKey, saveDeployKey }

package/src/command-helpers/compiler.js

@@ -1,7 +1,7 @@
 const URL = require('url').URL
-const ipfsHttpClient = require('ipfs-http-client')
-const toolbox = require('gluegun/toolbox')
-const Compiler = require('../compiler')
+import ipfsHttpClient from 'ipfs-http-client'
+import * as toolbox from 'gluegun/toolbox'
+import Compiler from '../compiler'
 
 // Helper function to construct a subgraph compiler
 const createCompiler = (
@@ -40,6 +40,4 @@ The IPFS URL must be of the following format: http(s)://host[:port]/[path]`)
   })
 }
 
-module.exports = {
-  createCompiler,
-}
+export { createCompiler }

package/src/command-helpers/data-sources.js

@@ -1,5 +1,5 @@
-const immutable = require('immutable')
-const { loadManifest } = require('../migrations/util/load-manifest')
+import immutable from 'immutable'
+import { loadManifest } from '../migrations/util/load-manifest'
 
 // Loads manifest from file path and returns all:
 // - data sources
@@ -16,11 +16,11 @@ const extractDataSourceByType = (manifest, dataSourceType, protocol) =>
     .get(dataSourceType, immutable.List())
     .reduce(
       (dataSources, dataSource, dataSourceIndex) =>
-      protocol.isValidKindName(dataSource.get('kind'))
-      ? dataSources.push(
-        immutable.Map({ path: [dataSourceType, dataSourceIndex], dataSource }),
-      )
-      : dataSources,
+        protocol.isValidKindName(dataSource.get('kind'))
+          ? dataSources.push(
+              immutable.Map({ path: [dataSourceType, dataSourceIndex], dataSource }),
+            )
+          : dataSources,
       immutable.List(),
     )
 
@@ -32,7 +32,4 @@ const fromManifest = (manifest, protocol) => {
   return dataSources.concat(templates)
 }
 
-module.exports = {
-  fromFilePath,
-  fromManifest,
-}
+export { fromFilePath, fromManifest }

package/src/command-helpers/fs.ts

@@ -0,0 +1,5 @@
+import path from 'path'
+
+const displayPath = (p: string) => path.relative(process.cwd(), p)
+
+export { displayPath }

package/src/command-helpers/gluegun.js

@@ -35,7 +35,7 @@ const fixParameters = (parameters, booleanOptions) => {
 
   if (unexpectedStringOptions.length > 1) {
     throw new Error(
-      `Unexpected value provided for one or more of ${optionNames}. See --help for more information.`
+      `Unexpected value provided for one or more of ${optionNames}. See --help for more information.`,
     )
   } else if (unexpectedStringOptions.length == 1) {
     let params = parameters.array
@@ -46,6 +46,4 @@ const fixParameters = (parameters, booleanOptions) => {
   }
 }
 
-module.exports = {
-  fixParameters,
-}
+export { fixParameters }

package/src/command-helpers/ipfs.ts

@@ -0,0 +1,3 @@
+const DEFAULT_IPFS_URL = 'https://api.thegraph.com/ipfs/' as const
+
+export { DEFAULT_IPFS_URL }

package/src/command-helpers/{jsonrpc.js → jsonrpc.ts}

@@ -1,16 +1,13 @@
-const jayson = require('jayson')
-const toolbox = require('gluegun/toolbox')
+import jayson from 'jayson'
+import { print } from 'gluegun'
 
-const createJsonRpcClient = url => {
-  let params = {
+const createJsonRpcClient = (url: URL) => {
+  const params = {
     host: url.hostname,
     port: url.port,
     path: url.pathname,
-  }
-
-  // username may be empty
-  if (url.password) {
-    params.auth = `${url.username}:${url.password}`
+    // username may be empty
+    auth: url.password ? `${url.username}:${url.password}` : undefined,
   }
 
   if (url.protocol === 'https:') {
@@ -18,16 +15,14 @@ const createJsonRpcClient = url => {
   } else if (url.protocol === 'http:') {
     return jayson.Client.http(params)
   } else {
-    toolbox.print.error(
-      `Unsupported protocol: ${url.protocol.substring(0, url.protocol.length - 1)}`
+    print.error(
+      `Unsupported protocol: ${url.protocol.substring(0, url.protocol.length - 1)}`,
     )
-    toolbox.print.error(
-      'The Graph Node URL must be of the following format: http(s)://host[:port]/[path]'
+    print.error(
+      'The Graph Node URL must be of the following format: http(s)://host[:port]/[path]',
     )
     return null
   }
 }
 
-module.exports = {
-  createJsonRpcClient,
-}
+export { createJsonRpcClient }

package/src/command-helpers/network.js

@@ -1,8 +1,14 @@
-const path = require('path')
-const yaml = require('yaml')
-const { step, withSpinner } = require('../command-helpers/spinner')
-
-const updateSubgraphNetwork = async (toolbox, manifest, network, networksFile, identifierName) =>
+import path from 'path'
+import yaml from 'yaml'
+import { step, withSpinner } from '../command-helpers/spinner'
+
+const updateSubgraphNetwork = async (
+  toolbox,
+  manifest,
+  network,
+  networksFile,
+  identifierName,
+) =>
   await withSpinner(
     `Update sources network`,
     `Failed to update sources network`,
@@ -11,41 +17,42 @@ const updateSubgraphNetwork = async (toolbox, manifest, network, networksFile, i
       let allNetworks
 
       step(spinner, `Reading networks config`)
-      allNetworks = await toolbox.filesystem.read(networksFile, "json")
+      allNetworks = await toolbox.filesystem.read(networksFile, 'json')
       let networkConfig = allNetworks[network]
 
       // Exit if the network passed with --network does not exits in networks.json
-      if(!networkConfig) {
+      if (!networkConfig) {
         throw new Error(`Network '${network}' was not found in '${networksFile}'`)
       }
 
       await toolbox.patching.update(manifest, content => {
         let subgraph = yaml.parse(content)
         let networkSources = Object.keys(networkConfig)
-        let subgraphSources = subgraph.dataSources.map(value => value.name);
+        let subgraphSources = subgraph.dataSources.map(value => value.name)
 
         // Update the dataSources network config
         subgraph.dataSources = subgraph.dataSources.map(source => {
-            if (!networkSources.includes(source.name)) {
-              throw new Error(`'${source.name}' was not found in the '${network}' configuration, please update!`)
-            }
-
-            if (hasChanges(identifierName, network, networkConfig[source.name], source)) {
-              step(spinner, `Update '${source.name}' network configuration`)
-              source.network = network
-              source.source = source.source.abi ? { abi: source.source.abi } : {}
-              Object.assign(source.source, networkConfig[source.name])
-            } else {
-              step(spinner, `Skip '${source.name}': No changes to network configuration`)
-            }
-
-            return source
+          if (!networkSources.includes(source.name)) {
+            throw new Error(
+              `'${source.name}' was not found in the '${network}' configuration, please update!`,
+            )
+          }
+
+          if (hasChanges(identifierName, network, networkConfig[source.name], source)) {
+            step(spinner, `Update '${source.name}' network configuration`)
+            source.network = network
+            source.source = source.source.abi ? { abi: source.source.abi } : {}
+            Object.assign(source.source, networkConfig[source.name])
+          } else {
+            step(spinner, `Skip '${source.name}': No changes to network configuration`)
           }
-        )
+
+          return source
+        })
 
         // All data sources shoud be on the same network,
         // so we have to update the network of all templates too.
-        if(subgraph.templates) {
+        if (subgraph.templates) {
           subgraph.templates = subgraph.templates.map(template => ({
             ...template,
             network,
@@ -55,37 +62,42 @@ const updateSubgraphNetwork = async (toolbox, manifest, network, networksFile, i
         let unsusedSources = networkSources.filter(x => !subgraphSources.includes(x))
 
         unsusedSources.forEach(source => {
-          step(spinner, `dataSource '${source}' from '${networksFile}' not found in ${manifest}`)
+          step(
+            spinner,
+            `dataSource '${source}' from '${networksFile}' not found in ${manifest}`,
+          )
         })
 
         let yaml_doc = new yaml.Document()
         yaml_doc.contents = subgraph
         return yaml_doc.toString()
       })
-  })
+    },
+  )
 
-const initNetworksConfig = async(toolbox, directory, identifierName) =>
+const initNetworksConfig = async (toolbox, directory, identifierName) =>
   await withSpinner(
     `Initialize networks config`,
     `Failed to initialize networks config`,
     `Warnings while initializing networks config`,
     async spinner => {
-      let subgraphStr = await toolbox.filesystem.read(path.join(directory, 'subgraph.yaml'))
+      let subgraphStr = await toolbox.filesystem.read(
+        path.join(directory, 'subgraph.yaml'),
+      )
       let subgraph = yaml.parse(subgraphStr)
 
-      const networks = subgraph.dataSources.reduce((acc, source) =>
-        Object.assign(
-          acc,
-          {
+      const networks = subgraph.dataSources.reduce(
+        (acc, source) =>
+          Object.assign(acc, {
             [source.network]: {
               [source.name]: {
                 [identifierName]: source.source.address,
                 startBlock: source.source.startBlock,
               },
             },
-          }
-        )
-      , {})
+          }),
+        {},
+      )
 
       await toolbox.filesystem.write(`${directory}/networks.json`, networks)
 
@@ -107,19 +119,21 @@ function hasChanges(identifierName, network, networkConfig, dataSource) {
   return networkChanged || addressChanged || startBlockChanged
 }
 
-const updateNetworksFile = async (toolbox, network, dataSource, address, networksFile) => {
-  await toolbox.patching.update(networksFile, (config) => {
-    if(Object.keys(config).includes(network)) {
+const updateNetworksFile = async (
+  toolbox,
+  network,
+  dataSource,
+  address,
+  networksFile,
+) => {
+  await toolbox.patching.update(networksFile, config => {
+    if (Object.keys(config).includes(network)) {
       Object.assign(config[network], { [dataSource]: { address } })
     } else {
-      Object.assign(config, { [network]: { [dataSource]: { address } }})
+      Object.assign(config, { [network]: { [dataSource]: { address } } })
     }
     return config
   })
 }
 
-module.exports = {
-  updateSubgraphNetwork,
-  initNetworksConfig,
-  updateNetworksFile
-}
+export { updateSubgraphNetwork, initNetworksConfig, updateNetworksFile }

package/src/command-helpers/network.test.js

@@ -1,9 +1,17 @@
-const { initNetworksConfig, updateSubgraphNetwork } = require('../command-helpers/network')
-const toolbox = require('gluegun/toolbox')
-const yaml = require('yaml')
-const path = require('path')
-
-const SUBGRAPH_PATH_BASE = path.join(__dirname,'..','..','..','..','examples','example-subgraph')
+import { initNetworksConfig, updateSubgraphNetwork } from '../command-helpers/network'
+import * as toolbox from 'gluegun/toolbox'
+import yaml from 'yaml'
+import path from 'path'
+
+const SUBGRAPH_PATH_BASE = path.join(
+  __dirname,
+  '..',
+  '..',
+  '..',
+  '..',
+  'examples',
+  'example-subgraph',
+)
 
 describe('initNetworksConfig', () => {
   beforeAll(async () => {
@@ -23,8 +31,8 @@ describe('initNetworksConfig', () => {
 
     let expected = {
       mainnet: {
-        ExampleSubgraph: { address: '0x22843e74c59580b3eaf6c233fa67d8b7c561a835' }
-      }
+        ExampleSubgraph: { address: '0x22843e74c59580b3eaf6c233fa67d8b7c561a835' },
+      },
     }
 
     expect(networks).toStrictEqual(expected)
@@ -35,12 +43,15 @@ describe('updateSubgraphNetwork', () => {
   beforeAll(async () => {
     let content = {
       optimism: {
-        ExampleSubgraph: { address: '0x12345...' }
-      }
+        ExampleSubgraph: { address: '0x12345...' },
+      },
     }
 
     await toolbox.filesystem.write(`${SUBGRAPH_PATH_BASE}/networks.json`, content)
-    await toolbox.filesystem.copy(`${SUBGRAPH_PATH_BASE}/subgraph.yaml`, `${SUBGRAPH_PATH_BASE}/subgraph_copy.yaml`)
+    await toolbox.filesystem.copy(
+      `${SUBGRAPH_PATH_BASE}/subgraph.yaml`,
+      `${SUBGRAPH_PATH_BASE}/subgraph_copy.yaml`,
+    )
   })
 
   afterAll(async () => {
@@ -60,13 +71,7 @@ describe('updateSubgraphNetwork', () => {
     expect(network).toBe('mainnet')
     expect(address).toBe('0x22843e74c59580b3eaf6c233fa67d8b7c561a835')
 
-    await updateSubgraphNetwork(
-      toolbox,
-      manifest,
-      'optimism',
-      networksFie,
-      'address'
-    )
+    await updateSubgraphNetwork(toolbox, manifest, 'optimism', networksFie, 'address')
 
     subgraph = await toolbox.filesystem.read(manifest)
     subgraphObj = yaml.parse(subgraph)
@@ -77,5 +82,4 @@ describe('updateSubgraphNetwork', () => {
     expect(network).toBe('optimism')
     expect(address).toBe('0x12345...')
   })
-
 })

package/src/command-helpers/node.js

@@ -1,5 +1,5 @@
 const URL = require('url').URL
-const { print } = require('gluegun/toolbox')
+import { print } from 'gluegun/toolbox'
 
 const SUBGRAPH_STUDIO_URL = 'https://api.studio.thegraph.com/deploy/'
 const HOSTED_SERVICE_URL = 'https://api.thegraph.com/deploy/'
@@ -8,7 +8,7 @@ const validateNodeUrl = node => new URL(node)
 
 const normalizeNodeUrl = node => new URL(node).toString()
 
-function chooseNodeUrl ({ product, studio, node, allowSimpleName }) {
+function chooseNodeUrl({ product, studio, node, allowSimpleName }) {
   if (node) {
     try {
       validateNodeUrl(node)
@@ -35,8 +35,4 @@ function chooseNodeUrl ({ product, studio, node, allowSimpleName }) {
   return { node, allowSimpleName }
 }
 
-module.exports = {
-  validateNodeUrl,
-  normalizeNodeUrl,
-  chooseNodeUrl
-}
+export { validateNodeUrl, normalizeNodeUrl, chooseNodeUrl }

package/src/command-helpers/scaffold.js

@@ -1,15 +1,15 @@
-const fs = require('fs-extra')
-const path = require('path')
-const prettier = require('prettier')
-const yaml = require('yaml')
-
-const { step } = require('./spinner')
-const Scaffold = require('../scaffold')
-const { generateEventIndexingHandlers } = require('../scaffold/mapping')
-const { generateEventType, abiEvents } = require('../scaffold/schema')
-const { generateTestsFiles } = require('../scaffold/tests')
-const { strings } = require('gluegun')
-const { Map } = require('immutable')
+import fs from 'fs-extra'
+import path from 'path'
+import prettier from 'prettier'
+import yaml from 'yaml'
+
+import { step } from './spinner'
+import Scaffold from '../scaffold'
+import { generateEventIndexingHandlers } from '../scaffold/mapping'
+import { generateEventType, abiEvents } from '../scaffold/schema'
+import { generateTestsFiles } from '../scaffold/tests'
+import { strings } from 'gluegun'
+import { Map } from 'immutable'
 
 const generateDataSource = async (
   protocol,
@@ -21,13 +21,25 @@ const generateDataSource = async (
   const protocolManifest = protocol.getManifestScaffold()
 
   return Map.of(
-    'kind', protocol.name,
-    'name', contractName,
-    'network', network,
-    'source', yaml.parse(prettier.format(protocolManifest.source({contract: contractAddress, contractName}),
-      {parser: 'yaml'})),
-    'mapping', yaml.parse(prettier.format(protocolManifest.mapping({abi, contractName}),
-      {parser: 'yaml'}))
+    'kind',
+    protocol.name,
+    'name',
+    contractName,
+    'network',
+    network,
+    'source',
+    yaml.parse(
+      prettier.format(
+        protocolManifest.source({ contract: contractAddress, contractName }),
+        { parser: 'yaml' },
+      ),
+    ),
+    'mapping',
+    yaml.parse(
+      prettier.format(protocolManifest.mapping({ abi, contractName }), {
+        parser: 'yaml',
+      }),
+    ),
   ).asMutable()
 }
 
@@ -130,11 +142,9 @@ const writeMapping = async (abi, protocol, contractName, entities) => {
 
 const writeTestsFiles = async (abi, protocol, contractName) => {
   const hasEvents = protocol.hasEvents()
-  const events = hasEvents
-    ? abiEvents(abi).toJS()
-    : []
+  const events = hasEvents ? abiEvents(abi).toJS() : []
 
-  if(events.length > 0) {
+  if (events.length > 0) {
     // If a contract is added to a subgraph that has no tests folder
     await fs.ensureDir('./tests/')
 
@@ -148,8 +158,7 @@ const writeTestsFiles = async (abi, protocol, contractName) => {
   }
 }
 
-module.exports = {
-  ...module.exports,
+export {
   generateScaffold,
   writeScaffold,
   generateDataSource,

package/src/command-helpers/{spinner.js → spinner.ts}

@@ -1,8 +1,8 @@
-const chalk = require('chalk')
-const immutable = require('immutable')
-const toolbox = require('gluegun/toolbox')
+import * as toolbox from 'gluegun'
 
-const step = (spinner, subject, text) => {
+export type Spinner = ReturnType<toolbox.GluegunPrint['spin']>
+
+export const step = (spinner: Spinner, subject: string, text: string) => {
   if (text) {
     spinner.stopAndPersist({
       text: toolbox.print.colors.muted(`${subject} ${text}`),
@@ -23,7 +23,12 @@ const step = (spinner, subject, text) => {
 //   spinner stops with the warning message and returns the `result` value.
 // Otherwise the spinner prints the in-progress message with a check mark
 //   and simply returns the value returned by `f`.
-const withSpinner = async (text, errorText, warningText, f) => {
+export const withSpinner = async (
+  text: string,
+  errorText: string,
+  warningText: string,
+  f: (spinner: Spinner) => Promise<any> | any, // TODO: type result
+) => {
   let spinner = toolbox.print.spin(text)
   try {
     let result = await f(spinner)
@@ -55,8 +60,3 @@ const withSpinner = async (text, errorText, warningText, f) => {
     throw e
   }
 }
-
-module.exports = {
-  step,
-  withSpinner,
-}