@graphprotocol/graph-cli 0.36.1 → 0.37.1-alpha-20221207192322-dd39b34

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @graphprotocol/graph-cli
+
+## 0.37.1-alpha-20221207192322-dd39b34
+
+### Patch Changes
+
+- [#1015](https://github.com/graphprotocol/graph-cli/pull/1015) [`0153cb5`](https://github.com/graphprotocol/graph-cli/commit/0153cb5be26d4334360218a9e9964398f9015882) Thanks [@saihaj](https://github.com/saihaj)! - fix fantom network init URLs

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@graphprotocol/graph-cli",
-  "version": "0.36.1",
+  "version": "0.37.1-alpha-20221207192322-dd39b34",
   "license": "(Apache-2.0 OR MIT)",
   "description": "CLI for building for and deploying to The Graph",
   "dependencies": {
-    "assemblyscript": "0.19.10",
+    "assemblyscript": "0.19.23",
     "binary-install-raw": "0.0.13",
     "chalk": "3.0.0",
     "chokidar": "3.5.1",
@@ -41,9 +41,12 @@
     "strip-ansi": "6.0.0",
     "tern": "0.24.3"
   },
+  "publishConfig": {
+    "access": "public"
+  },
   "scripts": {
     "test": "jest --verbose",
     "test:init": "jest tests/cli/init.test.js --verbose",
     "test:validation": "jest tests/cli/validation.test.js --verbose"
   }
-}
+}

package/src/command-helpers/abi.js

@@ -66,6 +66,8 @@ const getEtherscanLikeAPIUrl = (network) => {
     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`
   }
 }

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, headers, outputDir, outputFormat, skipMigrations, blockIpfsMethods, protocol }
+  { ipfs, headers, outputDir, outputFormat, skipMigrations, blockIpfsMethods, protocol },
 ) => {
   // Parse the IPFS URL
   let url

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

@@ -1,21 +1,24 @@
 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')
 
 describe('initNetworksConfig', () => {
   beforeAll(async () => {
-    await initNetworksConfig(toolbox, './examples/example-subgraph', 'address')
+    await initNetworksConfig(toolbox, SUBGRAPH_PATH_BASE, 'address')
   })
   afterAll(async () => {
-    await toolbox.filesystem.remove('./examples/example-subgraph/networks.json')
+    await toolbox.filesystem.remove(`${SUBGRAPH_PATH_BASE}/networks.json`)
   })
 
   test('generates networks.json from subgraph.yaml', () => {
-    expect(toolbox.filesystem.exists('./examples/example-subgraph/networks.json')).toBe('file')
+    expect(toolbox.filesystem.exists(`${SUBGRAPH_PATH_BASE}/networks.json`)).toBe('file')
   })
 
   test('Populates the networks.json file with the data from subgraph.yaml', async () => {
-    let networksStr = await toolbox.filesystem.read('./examples/example-subgraph/networks.json')
+    let networksStr = await toolbox.filesystem.read(`${SUBGRAPH_PATH_BASE}/networks.json`)
     let networks = JSON.parse(networksStr)
 
     let expected = {
@@ -36,18 +39,18 @@ describe('updateSubgraphNetwork', () => {
       }
     }
 
-    await toolbox.filesystem.write('./examples/example-subgraph/networks.json', content)
-    await toolbox.filesystem.copy('./examples/example-subgraph/subgraph.yaml', './examples/example-subgraph/subgraph_copy.yaml')
+    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`)
   })
 
   afterAll(async () => {
-    await toolbox.filesystem.remove('./examples/example-subgraph/networks.json')
-    await toolbox.filesystem.remove('./examples/example-subgraph/subgraph_copy.yaml')
+    await toolbox.filesystem.remove(`${SUBGRAPH_PATH_BASE}/networks.json`)
+    await toolbox.filesystem.remove(`${SUBGRAPH_PATH_BASE}/subgraph_copy.yaml`)
   })
 
   test('Updates subgraph.yaml', async () => {
-    let manifest = './examples/example-subgraph/subgraph_copy.yaml'
-    let networksFie = './examples/example-subgraph/networks.json'
+    let manifest = `${SUBGRAPH_PATH_BASE}/subgraph_copy.yaml`
+    let networksFie = `${SUBGRAPH_PATH_BASE}/networks.json`
     let subgraph = await toolbox.filesystem.read(manifest)
     let subgraphObj = yaml.parse(subgraph)
 

package/src/commands/build.js

@@ -6,6 +6,8 @@ const { updateSubgraphNetwork } = require('../command-helpers/network')
 const DataSourcesExtractor = require('../command-helpers/data-sources')
 const Protocol = require('../protocols')
 
+let buildDebug = require('../debug')('graph-cli:build')
+
 const HELP = `
 ${chalk.bold('graph build')} [options] ${chalk.bold('[<subgraph-manifest>]')}
 
@@ -41,7 +43,7 @@ module.exports = {
       w,
       watch,
       network,
-      networkFile
+      networkFile,
     } = toolbox.parameters.options
 
     // Support both short and long option variants
@@ -76,7 +78,7 @@ module.exports = {
     networkFile =
       networkFile !== undefined && networkFile !== ''
         ? networkFile
-        : filesystem.resolve("networks.json")
+        : filesystem.resolve('networks.json')
 
     // Show help text if requested
     if (help) {
@@ -95,7 +97,9 @@ module.exports = {
       return
     }
 
-    if (network && filesystem.exists(networkFile) !== "file") {
+    buildDebug('Detected protocol "%s" (%o)', protocol.name, protocol)
+
+    if (network && filesystem.exists(networkFile) !== 'file') {
       print.error(`Network file '${networkFile}' does not exists or is not a file!`)
       process.exitCode = 1
       return

package/src/commands/codegen.js

@@ -21,6 +21,8 @@ Options:
   -uc, --uncrashable-config <path>  Directory for uncrashable config (default: ./uncrashable-config.yaml)
   `
 
+let codegenDebug = require('../debug')('graph-cli:codegen')
+
 module.exports = {
   description: 'Generates AssemblyScript types for a subgraph',
   run: async toolbox => {
@@ -54,6 +56,7 @@ module.exports = {
       ;[manifest] = fixParameters(toolbox.parameters, {
         h,
         help,
+        skipMigrations,
         w,
         watch,
         u,
@@ -65,6 +68,8 @@ module.exports = {
       return
     }
 
+    codegenDebug('Initialized codegen manifest: %o', manifest)
+
     // Fall back to default values for options / parameters
     outputDir =
       outputDir !== undefined && outputDir !== ''

package/src/commands/init.js

@@ -26,6 +26,8 @@ const availableNetworks = Protocol.availableNetworks()
 
 const DEFAULT_EXAMPLE_SUBGRAPH = 'ethereum/gravatar'
 
+let initDebug = require('../debug')('graph-cli:init')
+
 const HELP = `
 ${chalk.bold('graph init')} [options] [subgraph-name] [directory]
 
@@ -170,10 +172,17 @@ const processInitForm = async (
       type: 'select',
       name: 'network',
       message: () => `${protocolInstance.displayName()} network`,
-      choices: () =>
-        availableNetworks
+      choices: () => {
+        initDebug(
+          'Generating list of available networks for protocol "%s" (%M)',
+          protocol,
+          availableNetworks.get(protocol),
+        )
+        return availableNetworks
           .get(protocol) // Get networks related to the chosen protocol.
-          .toArray(), // Needed because of gluegun. It can't even receive a JS iterable.
+          .toArray() // Needed because of gluegun. It can't even receive a JS iterable.
+      },
+
       skip: fromExample !== undefined,
       initial: network || 'mainnet',
       result: value => {

package/src/compiler/index.js

@@ -11,6 +11,9 @@ const Subgraph = require('../subgraph')
 const Watcher = require('../watcher')
 const { applyMigrations } = require('../migrations')
 const asc = require('./asc')
+const SubstreamsSubgraph = require('../protocols/substreams/subgraph')
+
+let compilerDebug = require('../debug')('graph-cli:compiler')
 
 class Compiler {
   constructor(options) {
@@ -20,36 +23,38 @@ class Compiler {
     this.blockIpfsMethods = options.blockIpfsMethods
     this.libsDirs = []
 
-    for (
-      let dir = path.resolve(this.sourceDir);
-      // Terminate after the root dir or when we have found node_modules
-      dir !== undefined;
-      // Continue with the parent directory, terminate after the root dir
-      dir = path.dirname(dir) === dir ? undefined : path.dirname(dir)
-    ) {
-      if (fs.existsSync(path.join(dir, 'node_modules'))) {
-        this.libsDirs.push(path.join(dir, 'node_modules'))
+    if (options.protocol.name !== 'substreams') {
+      for (
+        let dir = path.resolve(this.sourceDir);
+        // Terminate after the root dir or when we have found node_modules
+        dir !== undefined;
+        // Continue with the parent directory, terminate after the root dir
+        dir = path.dirname(dir) === dir ? undefined : path.dirname(dir)
+      ) {
+        if (fs.existsSync(path.join(dir, 'node_modules'))) {
+          this.libsDirs.push(path.join(dir, 'node_modules'))
+        }
       }
-    }
 
-    if (this.libsDirs.length === 0) {
-      throw Error(
-        `could not locate \`node_modules\` in parent directories of subgraph manifest`,
-      )
-    }
+      if (this.libsDirs.length === 0) {
+        throw Error(
+          `could not locate \`node_modules\` in parent directories of subgraph manifest`,
+        )
+      }
 
-    const globalsFile = path.join('@graphprotocol', 'graph-ts', 'global', 'global.ts')
-    const globalsLib = this.libsDirs.find(item => {
-      return fs.existsSync(path.join(item, globalsFile))
-    })
+      const globalsFile = path.join('@graphprotocol', 'graph-ts', 'global', 'global.ts')
+      const globalsLib = this.libsDirs.find(item => {
+        return fs.existsSync(path.join(item, globalsFile))
+      })
 
-    if (!globalsLib) {
-      throw Error(
-        'Could not locate `@graphprotocol/graph-ts` package in parent directories of subgraph manifest.',
-      )
-    }
+      if (!globalsLib) {
+        throw Error(
+          'Could not locate `@graphprotocol/graph-ts` package in parent directories of subgraph manifest.',
+        )
+      }
 
-    this.globalsFile = path.join(globalsLib, globalsFile)
+      this.globalsFile = path.join(globalsLib, globalsFile)
+    }
 
     this.protocol = this.options.protocol
     this.ABI = this.protocol.getABI()
@@ -83,7 +88,10 @@ class Compiler {
       }
       let subgraph = await this.loadSubgraph()
       let compiledSubgraph = await this.compileSubgraph(subgraph)
-      let localSubgraph = await this.writeSubgraphToOutputDirectory(compiledSubgraph)
+      let localSubgraph = await this.writeSubgraphToOutputDirectory(
+        this.options.protocol,
+        compiledSubgraph,
+      )
 
       if (this.ipfs !== undefined) {
         let ipfsHash = await this.uploadSubgraphToIPFS(localSubgraph)
@@ -214,6 +222,7 @@ class Compiler {
           dataSources.map(dataSource =>
             dataSource.updateIn(['mapping', 'file'], mappingPath =>
               this._compileDataSourceMapping(
+                this.protocol,
                 dataSource,
                 mappingPath,
                 compiledFiles,
@@ -243,7 +252,11 @@ class Compiler {
     )
   }
 
-  _compileDataSourceMapping(dataSource, mappingPath, compiledFiles, spinner) {
+  _compileDataSourceMapping(protocol, dataSource, mappingPath, compiledFiles, spinner) {
+    if (protocol.name == 'substreams') {
+      return
+    }
+
     try {
       let dataSourceName = dataSource.getIn(['name'])
 
@@ -378,7 +391,7 @@ class Compiler {
   _validateMappingContent(filePath) {
     const data = fs.readFileSync(filePath)
     if (
-      this.blockIpfsMethods && 
+      this.blockIpfsMethods &&
       (data.includes('ipfs.cat') || data.includes('ipfs.map'))
     ) {
       throw Error(`
@@ -389,7 +402,7 @@ class Compiler {
     }
   }
 
-  async writeSubgraphToOutputDirectory(subgraph) {
+  async writeSubgraphToOutputDirectory(protocol, subgraph) {
     const displayDir = `${this.displayPath(this.options.outputDir)}${
       toolbox.filesystem.separator
     }`
@@ -437,6 +450,30 @@ class Compiler {
                 )
             }
 
+            if (protocol.name == 'substreams') {
+              updatedDataSource = updatedDataSource
+                // Write data source ABIs to the output directory
+                .updateIn(['source', 'package'], substreamsPackage =>
+                  substreamsPackage.update('file', packageFile => {
+                    packageFile = path.resolve(this.sourceDir, packageFile)
+                    let packageContent = fs.readFileSync(packageFile)
+
+                    return path.relative(
+                      this.options.outputDir,
+                      this._writeSubgraphFile(
+                        packageFile,
+                        packageContent,
+                        this.sourceDir,
+                        this.subgraphDir(this.options.outputDir, dataSource),
+                        spinner,
+                      ),
+                    )
+                  }),
+                )
+
+              return updatedDataSource
+            }
+
             // The mapping file is already being written to the output
             // directory by the AssemblyScript compiler
             return updatedDataSource.updateIn(['mapping', 'file'], mappingFile =>
@@ -445,7 +482,7 @@ class Compiler {
                 path.resolve(this.sourceDir, mappingFile),
               ),
             )
-          })
+          }),
         )
 
         // Copy template files and update their paths
@@ -453,40 +490,40 @@ class Compiler {
           templates === undefined
             ? templates
             : templates.map(template => {
-              let updatedTemplate = template
-
-              if (this.protocol.hasABIs()) {
-                updatedTemplate = updatedTemplate
-                  // Write template ABIs to the output directory
-                  .updateIn(['mapping', 'abis'], abis =>
-                    abis.map(abi =>
-                      abi.update('file', abiFile => {
-                        abiFile = path.resolve(this.sourceDir, abiFile)
-                        let abiData = this.ABI.load(abi.get('name'), abiFile)
-                        return path.relative(
-                          this.options.outputDir,
-                          this._writeSubgraphFile(
-                            abiFile,
-                            JSON.stringify(abiData.data.toJS(), null, 2),
-                            this.sourceDir,
-                            this.subgraphDir(this.options.outputDir, template),
-                            spinner,
-                          ),
-                        )
-                      }),
-                    ),
-                  )
-              }
-
-              // The mapping file is already being written to the output
-              // directory by the AssemblyScript compiler
-              return updatedTemplate.updateIn(['mapping', 'file'], mappingFile =>
-                path.relative(
-                  this.options.outputDir,
-                  path.resolve(this.sourceDir, mappingFile),
-                ),
-              )
-            })
+                let updatedTemplate = template
+
+                if (this.protocol.hasABIs()) {
+                  updatedTemplate = updatedTemplate
+                    // Write template ABIs to the output directory
+                    .updateIn(['mapping', 'abis'], abis =>
+                      abis.map(abi =>
+                        abi.update('file', abiFile => {
+                          abiFile = path.resolve(this.sourceDir, abiFile)
+                          let abiData = this.ABI.load(abi.get('name'), abiFile)
+                          return path.relative(
+                            this.options.outputDir,
+                            this._writeSubgraphFile(
+                              abiFile,
+                              JSON.stringify(abiData.data.toJS(), null, 2),
+                              this.sourceDir,
+                              this.subgraphDir(this.options.outputDir, template),
+                              spinner,
+                            ),
+                          )
+                        }),
+                      ),
+                    )
+                }
+
+                // The mapping file is already being written to the output
+                // directory by the AssemblyScript compiler
+                return updatedTemplate.updateIn(['mapping', 'file'], mappingFile =>
+                  path.relative(
+                    this.options.outputDir,
+                    path.resolve(this.sourceDir, mappingFile),
+                  ),
+                )
+              }),
         )
 
         // Write the subgraph manifest itself
@@ -537,15 +574,28 @@ class Compiler {
         }
 
         // Upload all mappings
-        for (let [i, dataSource] of subgraph.get('dataSources').entries()) {
-          updates.push({
-            keyPath: ['dataSources', i, 'mapping', 'file'],
-            value: await this._uploadFileToIPFS(
-              dataSource.getIn(['mapping', 'file']),
-              uploadedFiles,
-              spinner,
-            ),
-          })
+        if (this.protocol.name !== 'substreams') {
+          for (let [i, dataSource] of subgraph.get('dataSources').entries()) {
+            updates.push({
+              keyPath: ['dataSources', i, 'mapping', 'file'],
+              value: await this._uploadFileToIPFS(
+                dataSource.getIn(['mapping', 'file']),
+                uploadedFiles,
+                spinner,
+              ),
+            })
+          }
+        } else {
+          for (let [i, dataSource] of subgraph.get('dataSources').entries()) {
+            updates.push({
+              keyPath: ['dataSources', i, 'source', 'package', 'file'],
+              value: await this._uploadFileToIPFS(
+                dataSource.getIn(['source', 'package', 'file']),
+                uploadedFiles,
+                spinner,
+              ),
+            })
+          }
         }
 
         for (let [i, template] of subgraph.get('templates', immutable.List()).entries()) {
@@ -584,6 +634,11 @@ class Compiler {
   }
 
   async _uploadFileToIPFS(maybeRelativeFile, uploadedFiles, spinner) {
+    compilerDebug(
+      'Resolving IPFS file "%s" from output dir "%s"',
+      maybeRelativeFile,
+      this.options.outputDir,
+    )
     let absoluteFile = path.resolve(this.options.outputDir, maybeRelativeFile)
     step(spinner, 'Add file to IPFS', this.displayPath(absoluteFile))
 

package/src/debug.js

@@ -0,0 +1,15 @@
+const debugFactory = require('debug')
+
+debugFactory.formatters.L = immutableList => {
+  return JSON.stringify(immutableList)
+}
+
+debugFactory.formatters.M = immutableMap => {
+  if (immutableMap.toMap != null) {
+    return JSON.stringify(immutableMap.toMap())
+  }
+
+  return immutableMap
+}
+
+module.exports = debugFactory