@graphprotocol/graph-cli 0.30.4 → 0.33.0

package/README.md

@@ -16,6 +16,7 @@ As of today, the command line interface supports the following commands:
 - `graph auth` — Stores a [Graph Node](https://github.com/graphprotocol/graph-node) access token in the system's keychain.
 - `graph local` — Runs tests against a [Graph Node](https://github.com/graphprotocol/graph-node) test environment (using Ganache by default).
 - `graph test` — Downloads and runs the [Matchstick](https://github.com/LimeChain/matchstick) rust binary in order to test a subgraph.
+- `graph add` - Adds a new datasource to the yaml file and writes the necessary changes to other files - schema.graphql, abi and mapping.
 
 ## How It Works
 
@@ -49,9 +50,9 @@ yarn global add @graphprotocol/graph-cli
 
 ## Getting Started
 
-The Graph CLI can be used with a local or self-hosted [Graph Node](https://github.com/graphprotocol/graph-node) or with the [Hosted Service](https://thegraph.com/explorer/). To help you get going, there are [quick start guides](https://thegraph.com/docs/quick-start) available for both.
+The Graph CLI can be used with a local or self-hosted [Graph Node](https://github.com/graphprotocol/graph-node) or with the [Hosted Service](https://thegraph.com/explorer/). To help you get going, there are [quick start guides](https://thegraph.com/docs/en/developer/quick-start/) available for both.
 
-If you are ready to dive into the details of building a subgraph from scratch, there is a [detailed walkthrough](https://thegraph.com/docs/define-a-subgraph) for that as well, along with API documentation for the [AssemblyScript API](https://thegraph.com/docs/assemblyscript-api).
+If you are ready to dive into the details of building a subgraph from scratch, there is a [detailed walkthrough](https://thegraph.com/docs/en/developer/create-subgraph-hosted/) for that as well, along with API documentation for the [AssemblyScript API](https://thegraph.com/docs/en/developer/assemblyscript-api/).
 
 ## Release process
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphprotocol/graph-cli",
-  "version": "0.30.4",
+  "version": "0.33.0",
   "license": "(Apache-2.0 OR MIT)",
   "description": "CLI for building for and deploying to The Graph",
   "dependencies": {
@@ -8,7 +8,7 @@
     "binary-install-raw": "0.0.13",
     "chalk": "3.0.0",
     "chokidar": "3.5.1",
-    "debug": "4.1.1",
+    "debug": "4.3.1",
     "docker-compose": "0.23.4",
     "dockerode": "2.5.8",
     "fs-extra": "9.0.0",
@@ -17,7 +17,7 @@
     "graphql": "15.5.0",
     "immutable": "3.8.2",
     "ipfs-http-client": "34.0.0",
-    "jayson": "3.2.0",
+    "jayson": "3.6.6",
     "js-yaml": "3.13.1",
     "node-fetch": "2.6.0",
     "pkginfo": "0.4.1",

package/src/codegen/types/conversions.js

@@ -143,9 +143,9 @@ const ASSEMBLYSCRIPT_TO_ETHEREUM_VALUE = [
     /^string\[([0-9]+)?\]$/,
     code => `ethereum.Value.fromStringArray(${code})`,
   ],
-  ['Tuple', 'tuple', code => `ethereum.Value.fromTuple(${code})`],
+  ['ethereum.Tuple', 'tuple', code => `ethereum.Value.fromTuple(${code})`],
   [
-    'Array<Tuple>',
+    'Array<ethereum.Tuple>',
     /^tuple\[([0-9]+)?\]$/,
     code => `ethereum.Value.fromTupleArray(${code})`,
   ],

package/src/command-helpers/abi.js

@@ -60,6 +60,11 @@ const getEtherscanLikeAPIUrl = (network) => {
     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`;
     default: return `https://api-${network}.etherscan.io/api`
   }
 }

package/src/command-helpers/compiler.js

@@ -6,7 +6,7 @@ const Compiler = require('../compiler')
 // Helper function to construct a subgraph compiler
 const createCompiler = (
   manifest,
-  { ipfs, outputDir, outputFormat, skipMigrations, blockIpfsMethods, protocol }
+  { ipfs, headers, outputDir, outputFormat, skipMigrations, blockIpfsMethods, protocol }
 ) => {
   // Parse the IPFS URL
   let url
@@ -25,6 +25,7 @@ The IPFS URL must be of the following format: http(s)://host[:port]/[path]`)
         host: url.hostname,
         port: url.port,
         'api-path': url.pathname.replace(/\/$/, '') + '/api/v0/',
+        headers,
       })
     : undefined
 

package/src/command-helpers/jsonrpc.js

@@ -3,12 +3,16 @@ const toolbox = require('gluegun/toolbox')
 
 const createJsonRpcClient = url => {
   let params = {
-    auth: url.auth,
     host: url.hostname,
     port: url.port,
     path: url.pathname,
   }
 
+  // username may be empty
+  if (url.password) {
+    params.auth = `${url.username}:${url.password}`
+  }
+
   if (url.protocol === 'https:') {
     return jayson.Client.https(params)
   } else if (url.protocol === 'http:') {

package/src/command-helpers/network.js

@@ -107,7 +107,19 @@ 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)) {
+      Object.assign(config[network], { [dataSource]: { address } })
+    } else {
+      Object.assign(config, { [network]: { [dataSource]: { address } }})
+    }
+    return config
+  })
+}
+
 module.exports = {
   updateSubgraphNetwork,
-  initNetworksConfig
+  initNetworksConfig,
+  updateNetworksFile
 }

package/src/command-helpers/scaffold.js

@@ -7,10 +7,17 @@ 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')
 
-const generateDataSource = async (protocol, contractName, network, contractAddress, abi) => {
+const generateDataSource = async (
+  protocol,
+  contractName,
+  network,
+  contractAddress,
+  abi,
+) => {
   const protocolManifest = protocol.getManifestScaffold()
 
   return Map.of(
@@ -89,13 +96,13 @@ const writeABI = async (abi, contractName) => {
 
 const writeSchema = async (abi, protocol, schemaPath, entities) => {
   const events = protocol.hasEvents()
-    ? abiEvents(abi).filter(event => entities.indexOf(event.get('name')) === -1).toJS()
+    ? abiEvents(abi)
+        .filter(event => entities.indexOf(event.get('name')) === -1)
+        .toJS()
     : []
 
   let data = prettier.format(
-    events.map(
-        event => generateEventType(event, protocol.name)
-      ).join('\n\n'),
+    events.map(event => generateEventType(event, protocol.name)).join('\n\n'),
     {
       parser: 'graphql',
     },
@@ -106,18 +113,33 @@ const writeSchema = async (abi, protocol, schemaPath, entities) => {
 
 const writeMapping = async (abi, protocol, contractName, entities) => {
   const events = protocol.hasEvents()
-    ? abiEvents(abi).filter(event => entities.indexOf(event.get('name')) === -1).toJS()
+    ? abiEvents(abi)
+        .filter(event => entities.indexOf(event.get('name')) === -1)
+        .toJS()
     : []
 
-  let mapping = prettier.format(
-    generateEventIndexingHandlers(
-        events,
-        contractName,
-      ),
-    { parser: 'typescript', semi: false },
-  )
+  let mapping = prettier.format(generateEventIndexingHandlers(events, contractName), {
+    parser: 'typescript',
+    semi: false,
+  })
+
+  await fs.writeFile(`./src/${strings.kebabCase(contractName)}.ts`, mapping, {
+    encoding: 'utf-8',
+  })
+}
+
+const writeTestsFiles = async (abi, contractName) => {
+  // If a contract is added to a subgraph that has no tests folder
+  await fs.ensureDir('./tests/')
+
+  const events = abiEvents(abi).toJS()
+  const testsFiles = generateTestsFiles(contractName, events, true)
 
-  await fs.writeFile(`./src/${strings.kebabCase(contractName)}.ts`, mapping, { encoding: 'utf-8' })
+  for (const [fileName, content] of Object.entries(testsFiles)) {
+    await fs.writeFile(`./tests/${fileName}`, content, {
+      encoding: 'utf-8',
+    })
+  }
 }
 
 module.exports = {
@@ -128,4 +150,5 @@ module.exports = {
   writeABI,
   writeSchema,
   writeMapping,
+  writeTestsFiles,
 }

package/src/commands/add.js

@@ -5,10 +5,11 @@ const { withSpinner } = require('../command-helpers/spinner')
 const Subgraph = require('../subgraph')
 const Protocol = require('../protocols')
 const DataSourcesExtractor = require('../command-helpers/data-sources')
-const { generateDataSource, writeABI, writeSchema, writeMapping } = require('../command-helpers/scaffold')
+const { generateDataSource, writeABI, writeSchema, writeMapping, writeTestsFiles } = require('../command-helpers/scaffold')
 const { loadAbiFromEtherscan, loadAbiFromBlockScout } = require('../command-helpers/abi')
 const EthereumABI = require('../protocols/ethereum/abi')
 const { fixParameters } = require('../command-helpers/gluegun')
+const { updateNetworksFile } = require('../command-helpers/network')
 
 const HELP = `
 ${chalk.bold('graph add')} <address> [<subgraph-manifest default: "./subgraph.yaml">]
@@ -18,11 +19,12 @@ ${chalk.dim('Options:')}
       --abi <path>              Path to the contract ABI (default: download from Etherscan)
       --contract-name           Name of the contract (default: Contract)
       --merge-entities          Whether to merge entities with the same name (default: false)
+      --network-file <path>     Networks config file path (default: "./networks.json")
   -h, --help                    Show usage information
 `
 
 module.exports = {
-  description: 'Creates a new subgraph with basic scaffolding',
+  description: 'Adds a new datasource to a subgraph',
   run: async toolbox => {
     // Obtain tools
     let { print, system } = toolbox
@@ -33,20 +35,12 @@ module.exports = {
       contractName,
       h,
       help,
-      mergeEntities
+      mergeEntities,
+      networkFile
     } = toolbox.parameters.options
 
-    let address = toolbox.parameters.first
-    let manifestPath = toolbox.parameters.second || './subgraph.yaml'
     contractName = contractName || 'Contract'
 
-    // Validate the address
-    if (!address) {
-      print.error('No contract address provided')
-      process.exitCode = 1
-      return
-    }
-
     try {
       fixParameters(toolbox.parameters, {
         h,
@@ -59,12 +53,22 @@ module.exports = {
       return
     }
 
+    let address = toolbox.parameters.first || toolbox.parameters.array[0]
+    let manifestPath = toolbox.parameters.second || toolbox.parameters.array[1] || './subgraph.yaml'
+
     // Show help text if requested
     if (help || h) {
       print.info(HELP)
       return
     }
 
+    // Validate the address
+    if (!address) {
+      print.error('No contract address provided')
+      process.exitCode = 1
+      return
+    }
+
     const dataSourcesAndTemplates = await DataSourcesExtractor.fromFilePath(manifestPath)
     let protocol = Protocol.fromDataSources(dataSourcesAndTemplates)
     let manifest = await Subgraph.load(manifestPath, { protocol })
@@ -99,8 +103,12 @@ module.exports = {
     await writeSchema(ethabi, protocol, result.getIn(['schema', 'file']), collisionEntities)
     await writeMapping(ethabi, protocol, contractName, collisionEntities)
 
+    if (protocol.hasEvents()) {
+      await writeTestsFiles(ethabi, contractName)
+    }
+
     let dataSources = result.get('dataSources')
-    let dataSource = await generateDataSource(protocol, 
+    let dataSource = await generateDataSource(protocol,
       contractName, network, address, ethabi)
 
     // Handle the collisions edge case by copying another data source yaml data
@@ -120,6 +128,10 @@ module.exports = {
 
     await Subgraph.write(result, manifestPath)
 
+    // Update networks.json
+    const networksFile = networkFile || "./networks.json"
+    await updateNetworksFile(toolbox, network, contractName, address, networksFile)
+
     // Detect Yarn and/or NPM
     let yarn = await system.which('yarn')
     let npm = await system.which('npm')
@@ -173,12 +185,12 @@ const updateEventNamesOnCollision = (ethabi, entities, contractName, mergeEntiti
     if (dataRow.get('type') === 'event'){
       if (entities.indexOf(dataRow.get('name')) !== -1) {
         if (entities.indexOf(`${contractName}${dataRow.get('name')}`) !== -1) {
-          print.error(`Contract name ('${contractName}') 
+          print.error(`Contract name ('${contractName}')
             + event name ('${dataRow.get('name')}') entity already exists.`)
           process.exitCode = 1
           return
         }
-        
+
         if (mergeEntities) {
           collisionEntities.push(dataRow.get('name'))
           abiData = abiData.asImmutable().delete(i) // needs to be immutable when deleting, yes you read that right - https://github.com/immutable-js/immutable-js/issues/1901

package/src/commands/build.js

@@ -17,8 +17,8 @@ Options:
   -t, --output-format <format>  Output format for mappings (wasm, wast) (default: wasm)
       --skip-migrations         Skip subgraph migrations (default: false)
   -w, --watch                   Regenerate types when subgraph files change (default: false)
-      --network <name>          Network to use from networks.json
-      --network-file <path>    Networks file (default: "./networks.json")
+      --network <name>          Network configuration to use from the networks config file
+      --network-file <path>     Networks config file path (default: "./networks.json")
 `
 
 module.exports = {

package/src/commands/deploy.js

@@ -14,6 +14,7 @@ const { assertManifestApiVersion, assertGraphTsVersion } = require('../command-h
 const DataSourcesExtractor = require('../command-helpers/data-sources')
 const { validateStudioNetwork } = require('../command-helpers/studio')
 const Protocol = require('../protocols')
+const { updateSubgraphNetwork } = require('../command-helpers/network')
 
 const HELP = `
 ${chalk.bold('graph deploy')} [options] ${chalk.bold('<subgraph-name>')} ${chalk.bold(
@@ -22,18 +23,21 @@ ${chalk.bold('graph deploy')} [options] ${chalk.bold('<subgraph-name>')} ${chalk
 
 Options:
 
-      --product <subgraph-studio|hosted-service>
+        --product <subgraph-studio|hosted-service>
                                 Selects the product to which to deploy
-      --studio                  Shortcut for --product subgraph-studio
-  -g, --node <node>             Graph node to which to deploy
-      --deploy-key <key>        User deploy key
-  -l  --version-label <label>   Version label used for the deployment
-  -h, --help                    Show usage information
-  -i, --ipfs <node>             Upload build results to an IPFS node (default: ${DEFAULT_IPFS_URL})
-      --debug-fork              ID of a remote subgraph whose store will be GraphQL queried
-  -o, --output-dir <path>       Output directory for build results (default: build/)
-      --skip-migrations         Skip subgraph migrations (default: false)
-  -w, --watch                   Regenerate types when subgraph files change (default: false)
+        --studio                  Shortcut for --product subgraph-studio
+  -g,   --node <node>             Graph node to which to deploy
+        --deploy-key <key>        User deploy key
+  -l    --version-label <label>   Version label used for the deployment
+  -h,   --help                    Show usage information
+  -i,   --ipfs <node>             Upload build results to an IPFS node (default: ${DEFAULT_IPFS_URL})
+  -hdr, --headers <map>           Add custom headers that will be used by the IPFS HTTP client (default: {})
+        --debug-fork              ID of a remote subgraph whose store will be GraphQL queried
+  -o,   --output-dir <path>       Output directory for build results (default: build/)
+        --skip-migrations         Skip subgraph migrations (default: false)
+  -w,   --watch                   Regenerate types when subgraph files change (default: false)
+        --network <name>          Network configuration to use from the networks config file
+        --network-file <path>     Networks config file path (default: "./networks.json")
 `
 
 const processForm = async (
@@ -51,7 +55,7 @@ const processForm = async (
       name: 'product',
       message: 'Product for which to deploy',
       choices: ['subgraph-studio', 'hosted-service'],
-      skip: 
+      skip:
         product === 'subgraph-studio' ||
         product === 'hosted-service' ||
         studio !== undefined || node !== undefined,
@@ -91,6 +95,8 @@ module.exports = {
       i,
       help,
       ipfs,
+      headers,
+      hdr,
       node,
       o,
       outputDir,
@@ -98,16 +104,27 @@ module.exports = {
       w,
       watch,
       debugFork,
+      network,
+      networkFile,
     } = toolbox.parameters.options
 
     // Support both long and short option variants
     help = help || h
     ipfs = ipfs || i || DEFAULT_IPFS_URL
+    headers = headers || hdr || "{}"
     node = node || g
     outputDir = outputDir || o
     watch = watch || w
     versionLabel = versionLabel || l
 
+    try {
+      headers = JSON.parse(headers)
+    } catch (e) {
+      print.error("Please make sure headers is a valid JSON value")
+      process.exitCode = 1
+      return
+    }
+
     let subgraphName, manifest
     try {
       ;[subgraphName, manifest] = fixParameters(toolbox.parameters, {
@@ -129,6 +146,10 @@ module.exports = {
       manifest !== undefined && manifest !== ''
         ? manifest
         : filesystem.resolve('subgraph.yaml')
+    networkFile =
+      networkFile !== undefined && networkFile !== ''
+        ? networkFile
+        : filesystem.resolve("networks.json")
 
     try {
       const dataSourcesAndTemplates = await DataSourcesExtractor.fromFilePath(manifest)
@@ -211,11 +232,17 @@ module.exports = {
       return
     }
 
+    if (network) {
+      let identifierName = protocol.getContract().identifierName()
+      await updateSubgraphNetwork(toolbox, manifest, network, networkFile, identifierName)
+    }
+
     const isStudio = node.match(/studio/)
     const isHostedService = node.match(/thegraph.com/) && !isStudio
 
     let compiler = createCompiler(manifest, {
       ipfs,
+      headers,
       outputDir,
       outputFormat: 'wasm',
       skipMigrations,

package/src/commands/init.js

@@ -1,10 +1,9 @@
 const chalk = require('chalk')
-const fetch = require('node-fetch')
-const immutable = require('immutable')
 const os = require('os')
 const path = require('path')
 const toolbox = require('gluegun/toolbox')
-const yaml = require('yaml')
+const fs = require('fs')
+const graphCli = require('../cli')
 
 const {
   getSubgraphBasename,
@@ -423,9 +422,9 @@ module.exports = {
           contractName,
           node,
           studio,
-          product,
+          product
         },
-        { commands },
+        { commands, addContract: false },
       )
     }
 
@@ -484,9 +483,9 @@ module.exports = {
           contractName: inputs.contractName,
           node,
           studio: inputs.studio,
-          product: inputs.product,
+          product: inputs.product
         },
-        { commands },
+        { commands, addContract: true },
       )
     }
   },
@@ -720,9 +719,9 @@ const initSubgraphFromContract = async (
     contractName,
     node,
     studio,
-    product,
+    product
   },
-  { commands },
+  { commands, addContract },
 ) => {
   let { print } = toolbox
 
@@ -815,5 +814,85 @@ const initSubgraphFromContract = async (
     return
   }
 
+  while (addContract) {
+    addContract = await addAnotherContract(toolbox, { protocolInstance, directory })
+  }
+
   printNextSteps(toolbox, { subgraphName, directory }, { commands })
 }
+
+const addAnotherContract = async (toolbox, { protocolInstance, directory }) => {
+  const addContractConfirmation = await toolbox.prompt.confirm('Add another contract?')
+
+  if (addContractConfirmation) {
+    let abiFromFile
+    let ProtocolContract = protocolInstance.getContract()
+
+    let questions = [
+      {
+        type: 'input',
+        name: 'contract',
+        message: () => `Contract ${ProtocolContract.identifierName()}`,
+        validate: async (value) => {
+          // Validate whether the contract is valid
+          const { valid, error } = validateContract(value, ProtocolContract)
+          return valid ? true : error
+        },
+      },
+      {
+        type: 'select',
+        name: 'localAbi',
+        message: 'Provide local ABI path?',
+        choices: ['yes', 'no'],
+        result: (value) => {
+          abiFromFile = value === 'yes' ? true : false
+          return abiFromFile
+        },
+      },
+      {
+        type: 'input',
+        name: 'abi',
+        message: 'ABI file (path)',
+        skip: () => abiFromFile === false
+      },
+      {
+        type: 'input',
+        name: 'contractName',
+        message: 'Contract Name',
+        initial: 'Contract',
+        validate: (value) => value && value.length > 0,
+      },
+    ]
+
+    // Get the cwd before process.chdir in order to switch back in the end of command execution
+    const cwd = process.cwd();
+
+    try {
+      let { abi, contract, contractName } = await toolbox.prompt.ask(questions)
+
+      if (fs.existsSync(directory)) {
+        process.chdir(directory)
+      }
+
+      let commandLine = ['add', contract, '--contract-name', contractName]
+
+      if (abiFromFile) {
+        if (abi.includes(directory)) {
+          commandLine.push('--abi', path.normalize(abi.replace(directory, '')))
+        } else {
+          commandLine.push('--abi', abi)
+        }
+      }
+
+      await graphCli.run(commandLine)
+    } catch (e) {
+      toolbox.print.error(e)
+      process.exit(1)
+    }
+    finally {
+      process.chdir(cwd)
+    }
+  }
+
+  return addContractConfirmation
+}

package/src/commands/test.js

@@ -180,10 +180,8 @@ async function getPlatform(logsOpt) {
 
   if (arch === 'x64' || isM1) {
     if (type === 'Darwin') {
-      if (majorVersion === 19) {
-        return 'binary-macos-10.15'
-      } else if (majorVersion === 18) {
-        return 'binary-macos-10.14'
+      if (majorVersion === 18 || majorVersion === 19) {
+        return 'binary-macos-10.15' // GitHub dropped support for macOS 10.14 in Actions, but it seems 10.15 binary works on 10.14 too
       } else if (isM1) {
         return 'binary-macos-11-m1'
       }
@@ -196,8 +194,6 @@ async function getPlatform(logsOpt) {
       } else {
         return 'binary-linux-20'
       }
-    } else if (type === 'Windows_NT') {
-      return 'binary-windows'
     }
   }
 

package/src/migrations/mapping_api_version_0_0_4.js

@@ -19,7 +19,7 @@ module.exports = {
       return 'graph-ts dependency not installed yet'
     }
 
-    let manifest = loadManifest(manifestFile)
+    let manifest = await loadManifest(manifestFile)
     return (
       // Only migrate if the graph-ts version is >= 0.22.0...
       // Coerce needed because we may be dealing with an alpha version

package/src/migrations/mapping_api_version_0_0_5.js

@@ -19,7 +19,7 @@ module.exports = {
       return 'graph-ts dependency not installed yet'
     }
 
-    let manifest = loadManifest(manifestFile)
+    let manifest = await loadManifest(manifestFile)
     return (
       // Only migrate if the graph-ts version is >= 0.24.0...
       // Coerce needed because we may be dealing with an alpha version

package/src/protocols/index.js

@@ -52,6 +52,7 @@ module.exports = class Protocol {
         'matic',
         'mumbai',
         'fantom',
+        'fantom-testnet',
         'bsc',
         'chapel',
         'clover',
@@ -60,6 +61,8 @@ module.exports = class Protocol {
         'celo',
         'celo-alfajores',
         'fuse',
+        'moonbeam',
+        'moonriver',
         'mbase',
         'arbitrum-one',
         'arbitrum-rinkeby',

package/src/protocols/near/manifest.graphql

@@ -33,6 +33,12 @@ type DataSource {
 type ContractSource {
   account: String
   startBlock: BigInt
+  accounts: PartialAccount
+}
+
+type PartialAccount {
+  prefixes: [String!]
+  suffixes: [String!]
 }
 
 type ContractMapping {

package/src/scaffold/ethereum.test.js

@@ -243,6 +243,265 @@ export function handleExampleEvent1(event: ExampleEvent1Event): void {
   entity.a = event.params.a
   entity.save()
 }
+`)
+  })
+
+  test('Test Files (default)', () => {
+    const files = scaffoldWithIndexEvents.generateTests()
+    const testFile = files['contract.test.ts']
+    const utilsFile = files['contract-utils.ts']
+    expect(testFile).toEqual(`\
+import {
+  assert,
+  describe,
+  test,
+  clearStore,
+  beforeAll,
+  afterAll
+} from \"matchstick-as/assembly/index\"
+import { BigInt, Bytes } from \"@graphprotocol/graph-ts\"
+import { ExampleEvent } from \"../generated/schema\"
+import { ExampleEvent as ExampleEventEvent } from \"../generated/Contract/Contract\"
+import { handleExampleEvent } from \"../src/contract\"
+import { createExampleEventEvent } from \"./contract-utils\"
+
+// Tests structure (matchstick-as >=0.5.0)
+// https://thegraph.com/docs/en/developer/matchstick/#tests-structure-0-5-0
+
+describe(\"Describe entity assertions\", () => {
+  beforeAll(() => {
+    let a = BigInt.fromI32(234)
+    let b = [Bytes.fromI32(1234567890)]
+    let param2 = \"Example string value\"
+    let c = \"ethereum.Tuple Not implemented\"
+    let d = \"Example string value\"
+    let newExampleEventEvent = createExampleEventEvent(a, b, param2, c, d)
+    handleExampleEvent(newExampleEventEvent)
+  })
+
+  afterAll(() => {
+    clearStore()
+  })
+
+  // For more test scenarios, see:
+  // https://thegraph.com/docs/en/developer/matchstick/#write-a-unit-test
+
+  test(\"ExampleEvent created and stored\", () => {
+    assert.entityCount(\"ExampleEvent\", 1)
+
+    // 0xa16081f360e3847006db660bae1c6d1b2e17ec2a is the default address used in newMockEvent() function
+    assert.fieldEquals(
+      \"ExampleEvent\",
+      \"0xa16081f360e3847006db660bae1c6d1b2e17ec2a-1\",
+      \"a\",
+      \"234\"
+    )
+    assert.fieldEquals(
+      \"ExampleEvent\",
+      \"0xa16081f360e3847006db660bae1c6d1b2e17ec2a-1\",
+      \"b\",
+      \"[1234567890]\"
+    )
+    assert.fieldEquals(
+      \"ExampleEvent\",
+      \"0xa16081f360e3847006db660bae1c6d1b2e17ec2a-1\",
+      \"param2\",
+      \"Example string value\"
+    )
+    assert.fieldEquals(
+      \"ExampleEvent\",
+      \"0xa16081f360e3847006db660bae1c6d1b2e17ec2a-1\",
+      \"c\",
+      \"ethereum.Tuple Not implemented\"
+    )
+    assert.fieldEquals(
+      \"ExampleEvent\",
+      \"0xa16081f360e3847006db660bae1c6d1b2e17ec2a-1\",
+      \"d\",
+      \"Example string value\"
+    )
+
+    // More assert options:
+    // https://thegraph.com/docs/en/developer/matchstick/#asserts
+  })
+})
+`)
+    expect(utilsFile).toEqual(`\
+import { newMockEvent } from \"matchstick-as\"
+import { ethereum, BigInt, Bytes } from \"@graphprotocol/graph-ts\"
+import { ExampleEvent, ExampleEvent1 } from \"../generated/Contract/Contract\"
+
+export function createExampleEventEvent(
+  a: BigInt,
+  b: Array<Bytes>,
+  param2: string,
+  c: ethereum.Tuple,
+  d: string
+): ExampleEvent {
+  let exampleEventEvent = changetype<ExampleEvent>(newMockEvent())
+
+  exampleEventEvent.parameters = new Array()
+
+  exampleEventEvent.parameters.push(
+    new ethereum.EventParam(\"a\", ethereum.Value.fromUnsignedBigInt(a))
+  )
+  exampleEventEvent.parameters.push(
+    new ethereum.EventParam(\"b\", ethereum.Value.fromBytesArray(b))
+  )
+  exampleEventEvent.parameters.push(
+    new ethereum.EventParam(\"param2\", ethereum.Value.fromString(param2))
+  )
+  exampleEventEvent.parameters.push(
+    new ethereum.EventParam(\"c\", ethereum.Value.fromTuple(c))
+  )
+  exampleEventEvent.parameters.push(
+    new ethereum.EventParam(\"d\", ethereum.Value.fromString(d))
+  )
+
+  return exampleEventEvent
+}
+
+export function createExampleEvent1Event(a: Bytes): ExampleEvent1 {
+  let exampleEvent1Event = changetype<ExampleEvent1>(newMockEvent())
+
+  exampleEvent1Event.parameters = new Array()
+
+  exampleEvent1Event.parameters.push(
+    new ethereum.EventParam(\"a\", ethereum.Value.fromFixedBytes(a))
+  )
+
+  return exampleEvent1Event
+}
+`)
+  })
+
+  test('Test Files (for indexing events)', () => {
+    const files = scaffoldWithIndexEvents.generateTests()
+    const testFile = files['contract.test.ts']
+    const utilsFile = files['contract-utils.ts']
+
+    expect(testFile).toEqual(`\
+import {
+  assert,
+  describe,
+  test,
+  clearStore,
+  beforeAll,
+  afterAll
+} from \"matchstick-as/assembly/index\"
+import { BigInt, Bytes } from \"@graphprotocol/graph-ts\"
+import { ExampleEvent } from \"../generated/schema\"
+import { ExampleEvent as ExampleEventEvent } from \"../generated/Contract/Contract\"
+import { handleExampleEvent } from \"../src/contract\"
+import { createExampleEventEvent } from \"./contract-utils\"
+
+// Tests structure (matchstick-as >=0.5.0)
+// https://thegraph.com/docs/en/developer/matchstick/#tests-structure-0-5-0
+
+describe(\"Describe entity assertions\", () => {
+  beforeAll(() => {
+    let a = BigInt.fromI32(234)
+    let b = [Bytes.fromI32(1234567890)]
+    let param2 = \"Example string value\"
+    let c = \"ethereum.Tuple Not implemented\"
+    let d = \"Example string value\"
+    let newExampleEventEvent = createExampleEventEvent(a, b, param2, c, d)
+    handleExampleEvent(newExampleEventEvent)
+  })
+
+  afterAll(() => {
+    clearStore()
+  })
+
+  // For more test scenarios, see:
+  // https://thegraph.com/docs/en/developer/matchstick/#write-a-unit-test
+
+  test(\"ExampleEvent created and stored\", () => {
+    assert.entityCount(\"ExampleEvent\", 1)
+
+    // 0xa16081f360e3847006db660bae1c6d1b2e17ec2a is the default address used in newMockEvent() function
+    assert.fieldEquals(
+      \"ExampleEvent\",
+      \"0xa16081f360e3847006db660bae1c6d1b2e17ec2a-1\",
+      \"a\",
+      \"234\"
+    )
+    assert.fieldEquals(
+      \"ExampleEvent\",
+      \"0xa16081f360e3847006db660bae1c6d1b2e17ec2a-1\",
+      \"b\",
+      \"[1234567890]\"
+    )
+    assert.fieldEquals(
+      \"ExampleEvent\",
+      \"0xa16081f360e3847006db660bae1c6d1b2e17ec2a-1\",
+      \"param2\",
+      \"Example string value\"
+    )
+    assert.fieldEquals(
+      \"ExampleEvent\",
+      \"0xa16081f360e3847006db660bae1c6d1b2e17ec2a-1\",
+      \"c\",
+      \"ethereum.Tuple Not implemented\"
+    )
+    assert.fieldEquals(
+      \"ExampleEvent\",
+      \"0xa16081f360e3847006db660bae1c6d1b2e17ec2a-1\",
+      \"d\",
+      \"Example string value\"
+    )
+
+    // More assert options:
+    // https://thegraph.com/docs/en/developer/matchstick/#asserts
+  })
+})
+`)
+    expect(utilsFile).toEqual(`\
+import { newMockEvent } from \"matchstick-as\"
+import { ethereum, BigInt, Bytes } from \"@graphprotocol/graph-ts\"
+import { ExampleEvent, ExampleEvent1 } from \"../generated/Contract/Contract\"
+
+export function createExampleEventEvent(
+  a: BigInt,
+  b: Array<Bytes>,
+  param2: string,
+  c: ethereum.Tuple,
+  d: string
+): ExampleEvent {
+  let exampleEventEvent = changetype<ExampleEvent>(newMockEvent())
+
+  exampleEventEvent.parameters = new Array()
+
+  exampleEventEvent.parameters.push(
+    new ethereum.EventParam(\"a\", ethereum.Value.fromUnsignedBigInt(a))
+  )
+  exampleEventEvent.parameters.push(
+    new ethereum.EventParam(\"b\", ethereum.Value.fromBytesArray(b))
+  )
+  exampleEventEvent.parameters.push(
+    new ethereum.EventParam(\"param2\", ethereum.Value.fromString(param2))
+  )
+  exampleEventEvent.parameters.push(
+    new ethereum.EventParam(\"c\", ethereum.Value.fromTuple(c))
+  )
+  exampleEventEvent.parameters.push(
+    new ethereum.EventParam(\"d\", ethereum.Value.fromString(d))
+  )
+
+  return exampleEventEvent
+}
+
+export function createExampleEvent1Event(a: Bytes): ExampleEvent1 {
+  let exampleEvent1Event = changetype<ExampleEvent1>(newMockEvent())
+
+  exampleEvent1Event.parameters = new Array()
+
+  exampleEvent1Event.parameters.push(
+    new ethereum.EventParam(\"a\", ethereum.Value.fromFixedBytes(a))
+  )
+
+  return exampleEvent1Event
+}
 `)
   })
 })

package/src/scaffold/index.js

@@ -15,6 +15,7 @@ const {
   generateExampleEntityType,
 } = require('./schema')
 const { generateEventIndexingHandlers } = require('./mapping')
+const { generateTestsFiles } = require('./tests')
 const { getSubgraphBasename } = require('../command-helpers/subgraph')
 
 module.exports = class Scaffold {
@@ -48,11 +49,15 @@ module.exports = class Scaffold {
             `--node http://localhost:8020/ ` +
             `--ipfs http://localhost:5001 ` +
             this.subgraphName,
+          'test': 'graph test',
         },
         dependencies: {
           '@graphprotocol/graph-cli': GRAPH_CLI_VERSION,
           '@graphprotocol/graph-ts': `0.27.0`,
         },
+        devDependencies: {
+          'matchstick-as': `0.5.0`,
+        },
       }),
       { parser: 'json' },
     )
@@ -137,6 +142,12 @@ dataSources:
       : undefined
   }
 
+  generateTests() {
+    return this.protocol.hasEvents()
+      ?  generateTestsFiles(this.contractName, abiEvents(this.abi).toJS(), this.indexEvents)
+      : undefined
+  }
+
   generate() {
     return {
       'package.json': this.generatePackageJson(),
@@ -145,6 +156,7 @@ dataSources:
       'tsconfig.json': this.generateTsConfig(),
       src: { [`${strings.kebabCase(this.contractName)}.ts`]: this.generateMapping() },
       abis: this.generateABIs(),
+      tests: this.generateTests(),
     }
   }
 }

package/src/scaffold/tests.js

@@ -0,0 +1,196 @@
+const prettier = require('prettier')
+const { strings } = require('gluegun')
+const { ascTypeForEthereum, ethereumFromAsc } = require("../codegen/types")
+
+const VARIABLES_VALUES = {
+  "i32": 123,
+  "BigInt": 234,
+  "Bytes": 1234567890,
+  "Address": "0x0000000000000000000000000000000000000001",
+  "string": "Example string value",
+  "bool": true,
+}
+
+const generateTestsFiles = (contract, events, indexEvents) => {
+  const eventsTypes = events
+    .flatMap(event =>
+      event
+        .inputs
+        .map(input => {
+          // If the asc type is Array<T> we need to check if T is a native type or a custom graph-ts type
+          // If we don't do that we may miss a type that should be imported from graph-ts
+          const ascType = ascTypeForEthereum(input.type)
+          const inner = fetchArrayInnerType(ascType)
+          return inner ? inner[1] : ascType
+        })
+    ).filter(type => !type.startsWith("ethereum.") && !isNativeType(type))
+  const importTypes = [...new Set(eventsTypes)].join(', ')
+
+  return {
+    [`${strings.kebabCase(contract)}.test.ts`]: prettier.format(generateExampleTest(contract, events[0], indexEvents, importTypes), { parser: 'typescript', semi: false }),
+    [`${strings.kebabCase(contract)}-utils.ts`]: prettier.format(generateTestHelper(contract, events, importTypes), { parser: 'typescript', semi: false }),
+  }
+}
+
+/*
+  Generates the arguments that will be passed to the mock event function from the event inputs. Example:
+  let id = BigInt.fromI32(234)
+  let owner = Address.fromString("0x0000000000000000000000000000000000000001")
+  let displayName = "Example string value"
+  let imageUrl = "Example string value"
+*/
+const generateArguments = (eventInputs) => {
+  return eventInputs.map((input, index) => {
+    let ascType = ascTypeForEthereum(input.type)
+    return `let ${input.name || `param${index}`} = ${assignValue(ascType, input.name)}`
+  }).join('\n')
+}
+
+// Generates the value that will be assigned to a variable in generateArguments()
+const assignValue = (type) => {
+  switch (type) {
+    case "string":
+      return `"${VARIABLES_VALUES[type]}"`
+    case "BigInt":
+      return `BigInt.fromI32(${VARIABLES_VALUES[type]})`
+    case "Address":
+      return `Address.fromString("${VARIABLES_VALUES[type]}")`
+    case "Bytes":
+      return `Bytes.fromI32(${VARIABLES_VALUES[type]})`
+    case fetchArrayInnerType(type)?.input:
+      innerType = fetchArrayInnerType(type)[1]
+      return `[${assignValue(innerType)}]`
+    default:
+      let value = VARIABLES_VALUES[type]
+      return value ? value : `"${type} Not implemented"`
+  }
+}
+
+/*
+  Generates the assert.fieldEquals() for a given entity and event inputs. Example:
+  assert.fieldEquals(
+    "ExampleEntity",
+    "0xa16081f360e3847006db660bae1c6d1b2e17ec2a",
+    "owner",
+    "0x0000000000000000000000000000000000000001"
+  )
+*/
+const generateFieldsAssertions = (entity, eventInputs, indexEvents) => eventInputs.filter(input => input.name != "id").map((input, index) =>
+  `assert.fieldEquals(
+    "${entity}",
+    "0xa16081f360e3847006db660bae1c6d1b2e17ec2a${indexEvents ? "-1" : ""}",
+    "${input.name || `param${index}`}",
+    "${expectedValue(ascTypeForEthereum(input.type))}"
+  )`
+).join('\n')
+
+// Returns the expected value for a given type in generateFieldsAssertions()
+const expectedValue = type => {
+  switch (type) {
+    case fetchArrayInnerType(type)?.input:
+      innerType = fetchArrayInnerType(type)[1]
+      return `[${expectedValue(innerType)}]`
+    default:
+      let value = VARIABLES_VALUES[type]
+      return value ? value : `${type} Not implemented`
+  }
+}
+
+// Checks if the type is a native AS type or should be imported from graph-ts
+const isNativeType = type => {
+  let natives = [
+    /i32/,
+    /string/,
+    /boolean/
+  ]
+
+  return natives.some(rx => rx.test(type));
+}
+
+const fetchArrayInnerType = type => type.match(/Array<(.*?)>/)
+
+// Generates the example test.ts file
+const generateExampleTest = (contract, event, indexEvents, importTypes) => {
+  const entity = indexEvents ? `${event._alias}` : 'ExampleEntity'
+  const eventInputs = event.inputs
+  const eventName = event._alias
+
+  return `
+  import { assert, describe, test, clearStore, beforeAll, afterAll } from "matchstick-as/assembly/index"
+  import { ${importTypes} } from "@graphprotocol/graph-ts"
+  import { ${entity} } from "../generated/schema"
+  import { ${indexEvents ? `${eventName} as ${eventName}Event` : eventName} } from "../generated/${contract}/${contract}"
+  import { handle${eventName} } from "../src/${strings.kebabCase(contract)}"
+  import { create${eventName}Event } from "./${strings.kebabCase(contract)}-utils"
+
+
+  // Tests structure (matchstick-as >=0.5.0)
+  // https://thegraph.com/docs/en/developer/matchstick/#tests-structure-0-5-0
+
+  describe("Describe entity assertions", () => {
+    beforeAll(() => {
+      ${generateArguments(eventInputs)}
+      let new${eventName}Event = create${eventName}Event(${eventInputs.map((input, index) => input.name || `param${index}`).join(', ')});
+      handle${eventName}(new${eventName}Event)
+    })
+
+    afterAll(() => {
+      clearStore()
+    })
+
+    // For more test scenarios, see:
+    // https://thegraph.com/docs/en/developer/matchstick/#write-a-unit-test
+
+    test("${entity} created and stored", () => {
+      assert.entityCount('${entity}', 1)
+
+      // 0xa16081f360e3847006db660bae1c6d1b2e17ec2a is the default address used in newMockEvent() function
+      ${generateFieldsAssertions(entity, eventInputs, indexEvents)}
+
+      // More assert options:
+      // https://thegraph.com/docs/en/developer/matchstick/#asserts
+    })
+  })
+`
+}
+
+// Generates the utils helper file
+const generateTestHelper = (contract, events, importTypes) => {
+  const eventsNames = events.map(event => event._alias)
+
+  return `
+  import { newMockEvent } from 'matchstick-as';
+  import { ethereum, ${importTypes} } from '@graphprotocol/graph-ts';
+  import { ${eventsNames.join(", ")} } from '../generated/${contract}/${contract}';
+
+  ${generateMockedEvents(events).join("\n")}`
+}
+
+const generateMockedEvents = events =>
+  events.reduce(
+    (acc, event) => acc.concat(generateMockedEvent(event)),
+    [],
+  )
+
+const generateMockedEvent = event => {
+  const varName = `${strings.camelCase(event._alias)}Event`
+  const fnArgs = event.inputs.map((input, index) => `${input.name || `param${index}`}: ${ascTypeForEthereum(input.type)}`);
+  const ascToEth = event.inputs.map((input, index) => `${varName}.parameters.push(new ethereum.EventParam("${input.name || `param${index}`}", ${ethereumFromAsc(input.name || `param${index}`, input.type)}))`);
+
+  return `
+    export function create${event._alias}Event(${fnArgs.join(', ')}): ${event._alias} {
+      let ${varName} = changetype<${event._alias}>(newMockEvent());
+
+      ${varName}.parameters = new Array();
+
+      ${ascToEth.join('\n')}
+
+      return ${varName};
+    }
+  `
+
+}
+
+module.exports = {
+  generateTestsFiles,
+}

package/tests/cli/validation/near-is-valid/subgraph.yaml

@@ -10,6 +10,14 @@ dataSources:
     source:
       account: wnear.flux-dev
       startBlock: 1
+      accounts:
+        prefixes:
+          - some-prefix
+          - a-prefix.with-dot
+        suffixes:
+          - suffix.near
+          - near
+          - another-suffix.testnet
     mapping:
       apiVersion: 0.0.5
       language: wasm/assemblyscript