@graphprotocol/graph-cli 0.36.1 → 0.37.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphprotocol/graph-cli",
-  "version": "0.36.1",
+  "version": "0.37.0",
   "license": "(Apache-2.0 OR MIT)",
   "description": "CLI for building for and deploying to The Graph",
   "dependencies": {

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/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

package/src/protocols/index.js

@@ -6,17 +6,23 @@ const EthereumABI = require('./ethereum/abi')
 const EthereumSubgraph = require('./ethereum/subgraph')
 const NearSubgraph = require('./near/subgraph')
 const CosmosSubgraph = require('./cosmos/subgraph')
+const SubstreamsSubgraph = require('./substreams/subgraph')
 const EthereumContract = require('./ethereum/contract')
 const NearContract = require('./near/contract')
+const ArweaveManifestScaffold = require('./arweave/scaffold/manifest')
 const EthereumManifestScaffold = require('./ethereum/scaffold/manifest')
 const NearManifestScaffold = require('./near/scaffold/manifest')
 const CosmosManifestScaffold = require('./cosmos/scaffold/manifest')
+const SubstreamsManifestScaffold = require('./substreams/scaffold/manifest')
 const ArweaveMappingScaffold = require('./arweave/scaffold/mapping')
 const EthereumMappingScaffold = require('./ethereum/scaffold/mapping')
 const NearMappingScaffold = require('./near/scaffold/mapping')
 const CosmosMappingScaffold = require('./cosmos/scaffold/mapping')
+const { ThrowStatement } = require('assemblyscript')
 
-module.exports = class Protocol {
+let protocolDebug = require('../debug')('graph-cli:protocol')
+
+class Protocol {
   static fromDataSources(dataSourcesAndTemplates) {
     const firstDataSourceKind = dataSourcesAndTemplates[0].kind
     return new Protocol(firstDataSourceKind)
@@ -24,6 +30,27 @@ module.exports = class Protocol {
 
   constructor(name) {
     this.name = Protocol.normalizeName(name)
+
+    switch (this.name) {
+      case 'arweave':
+        this.config = arweaveProtocol
+        break
+      case 'cosmos':
+        this.config = cosmosProtocol
+        break
+      case 'ethereum':
+        this.config = ethereumProtocol
+        break
+      case 'near':
+        this.config = nearProtocol
+        break
+      case 'substreams':
+        this.config = substreamsProtocol
+        break
+      default:
+      // Do not throw when undefined, a better error message is printed after the constructor
+      // when validating the Subgraph itself
+    }
   }
 
   static availableProtocols() {
@@ -33,12 +60,13 @@ module.exports = class Protocol {
       arweave: ['arweave'],
       ethereum: ['ethereum', 'ethereum/contract'],
       near: ['near'],
-      cosmos: ['cosmos']
+      cosmos: ['cosmos'],
+      substreams: ['substreams'],
     })
   }
 
   static availableNetworks() {
-    return immutable.fromJS({
+    let networks = immutable.fromJS({
       arweave: ['arweave-mainnet'],
       ethereum: [
         'mainnet',
@@ -74,30 +102,30 @@ module.exports = class Protocol {
         'cosmoshub-4',
         'theta-testnet-001', // CosmosHub testnet
         'osmosis-1',
-        'osmo-test-4',       // Osmosis testnet
-        'juno-1', 
-        'uni-3'              // Juno testnet
+        'osmo-test-4', // Osmosis testnet
+        'juno-1',
+        'uni-3', // Juno testnet
       ],
     })
+
+    let allNetworks = []
+    networks.forEach(value => {
+      allNetworks.push(...value)
+    })
+
+    networks = networks.set('substreams', immutable.fromJS(allNetworks))
+
+    return networks
   }
 
   static normalizeName(name) {
-    return Protocol.availableProtocols().findKey(possibleNames =>
-      possibleNames.includes(name),
-    )
+    return Protocol.availableProtocols().findKey(possibleNames => {
+      return possibleNames.includes(name)
+    })
   }
 
   displayName() {
-    switch (this.name) {
-      case 'arweave':
-        return 'Arweave'
-      case 'ethereum':
-        return 'Ethereum'
-      case 'near':
-        return 'NEAR'
-      case 'cosmos':
-        return 'Cosmos'
-    }
+    return this.config.displayName
   }
 
   // Receives a data source kind, and checks if it's valid
@@ -109,68 +137,34 @@ module.exports = class Protocol {
   }
 
   hasABIs() {
-    switch (this.name) {
-      case 'arweave':
-        return false
-      case 'ethereum':
-        return true
-      case 'near':
-        return false
-      case 'cosmos':
-        return false
-    }
+    return this.config.abi != null
   }
 
   hasContract() {
-    switch (this.name) {
-      case 'arweave':
-        return false
-      case 'ethereum':
-        return true
-      case 'near':
-        return true
-      case 'cosmos':
-        return false
-    }
+    return this.config.contract != null
   }
 
   hasEvents() {
-    switch (this.name) {
-      case 'arweave':
-        return false
-      case 'ethereum':
-        return true
-      case 'near':
-        return false
-      case 'cosmos':
-        return false
-    }
+    // A problem with hasEvents usage in the codebase is that it's almost every where
+    // where used, the ABI data is actually use after the conditional, so it seems
+    // both concept are related. So internally, we map to this condition.
+    return this.hasABIs()
   }
 
   hasTemplates() {
-    switch (this.name) {
-      case 'arweave':
-        return false
-      case 'ethereum':
-        return true
-      case 'near':
-        return false
-      case 'cosmos':
-        return false
-    }
+    return this.config.getTemplateCodeGen != null
+  }
+
+  hasDataSourceMappingFile() {
+    return this.config.getMappingScaffold != null
   }
 
   getTypeGenerator(options) {
-    switch (this.name) {
-      case 'arweave':
-        return null
-      case 'ethereum':
-        return new EthereumTypeGenerator(options)
-      case 'near':
-        return null
-      case 'cosmos':
-        return null
+    if (this.config == null || this.config.getTypeGenerator == null) {
+      return null
     }
+
+    return this.config.getTypeGenerator(options)
   }
 
   getTemplateCodeGen(template) {
@@ -180,80 +174,98 @@ module.exports = class Protocol {
       )
     }
 
-    switch (this.name) {
-      case 'ethereum':
-        return new EthereumTemplateCodeGen(template)
-      default:
-        throw new Error(`Template data sources with kind '${this.name}' is unknown`)
-    }
+    return this.config.getTemplateCodeGen(template)
   }
 
   getABI() {
-    switch (this.name) {
-      case 'arweave':
-        return null
-      case 'ethereum':
-        return EthereumABI
-      case 'near':
-        return null
-      case 'cosmos':
-        return null
-    }
+    return this.config.abi
   }
 
   getSubgraph(options = {}) {
-    const optionsWithProtocol = { ...options, protocol: this }
-
-    switch (this.name) {
-      case 'arweave':
-        return new ArweaveSubgraph(optionsWithProtocol)
-      case 'ethereum':
-        return new EthereumSubgraph(optionsWithProtocol)
-      case 'near':
-        return new NearSubgraph(optionsWithProtocol)
-      case 'cosmos':
-        return new CosmosSubgraph(optionsWithProtocol)
-      default:
-        throw new Error(`Data sources with kind '${this.name}' are not supported yet`)
-    }
+    return this.config.getSubgraph({ ...options, protocol: this })
   }
 
   getContract() {
-    switch (this.name) {
-      case 'arweave':
-        return null
-      case 'ethereum':
-        return EthereumContract
-      case 'near':
-        return NearContract
-      case 'cosmos':
-        return null
-    }
+    return this.config.contract
   }
 
   getManifestScaffold() {
-    switch (this.name) {
-      case 'arweave':
-        return ArweaveMappingScaffold
-      case 'ethereum':
-        return EthereumManifestScaffold
-      case 'near':
-        return NearManifestScaffold
-      case 'cosmos':
-        return CosmosManifestScaffold
-    }
+    return this.config.manifestScaffold
   }
 
   getMappingScaffold() {
-    switch (this.name) {
-      case 'arweave':
-        return ArweaveMappingScaffold
-      case 'ethereum':
-        return EthereumMappingScaffold
-      case 'near':
-        return NearMappingScaffold
-      case 'cosmos':
-        return CosmosMappingScaffold
-    }
+    return this.config.mappingScaffold
   }
 }
+
+const arweaveProtocol = {
+  displayName: 'Arweave',
+  abi: undefined,
+  contract: undefined,
+  getTemplateCodeGen: undefined,
+  getTypeGenerator: undefined,
+  getSubgraph(options) {
+    return new ArweaveSubgraph(options)
+  },
+  manifestScaffold: ArweaveManifestScaffold,
+  mappingScaffold: ArweaveMappingScaffold,
+}
+
+const cosmosProtocol = {
+  displayName: 'Cosmos',
+  abi: undefined,
+  contract: undefined,
+  getTemplateCodeGen: undefined,
+  getTypeGenerator: undefined,
+  getSubgraph(options) {
+    return new CosmosSubgraph(options)
+  },
+  manifestScaffold: CosmosManifestScaffold,
+  mappingScaffold: CosmosMappingScaffold,
+}
+
+const ethereumProtocol = {
+  displayName: 'Ethereum',
+  abi: EthereumABI,
+  contract: EthereumContract,
+  getTemplateCodeGen(template) {
+    return new EthereumTemplateCodeGen(template)
+  },
+  getTypeGenerator(options) {
+    return new EthereumTypeGenerator(options)
+  },
+  getSubgraph(options) {
+    return new EthereumSubgraph(options)
+  },
+  manifestScaffold: EthereumManifestScaffold,
+  mappingScaffold: EthereumMappingScaffold,
+}
+
+const nearProtocol = {
+  displayName: 'NEAR',
+  abi: undefined,
+  contract: NearContract,
+  getTypeGenerator: undefined,
+  getTemplateCodeGen: undefined,
+  getSubgraph(options) {
+    return new NearSubgraph(options)
+  },
+  manifestScaffold: NearManifestScaffold,
+  mappingScaffold: NearMappingScaffold,
+}
+
+const substreamsProtocol = {
+  displayName: 'Substreams',
+  abi: undefined,
+  contract: undefined,
+  getTypeGenerator: undefined,
+  getTemplateCodeGen: undefined,
+  getSubgraph(options) {
+    return new SubstreamsSubgraph(options)
+  },
+  manifestScaffold: SubstreamsManifestScaffold,
+  mappingScaffold: undefined,
+}
+
+protocolDebug('Available networks %M', Protocol.availableNetworks())
+module.exports = Protocol

package/src/protocols/substreams/manifest.graphql

@@ -0,0 +1,45 @@
+# Each referenced type's in any of the types below must be listed
+# here either as `scalar` or `type` for the validation code to work
+# properly.
+#
+# That's why `String` is listed as a scalar even though it's built-in
+# GraphQL basic types.
+scalar String
+scalar File
+scalar BigInt
+
+type SubgraphManifest {
+  specVersion: String!
+  features: [String!]
+  schema: Schema!
+  description: String
+  repository: String
+  graft: Graft
+  dataSources: [DataSource!]!
+}
+
+type Schema {
+  file: File!
+}
+
+type DataSource {
+  kind: String!
+  name: String!
+  network: String
+  source: SubstreamsSource!
+  mapping: SubstreamMapping!
+}
+
+type SubstreamsSource {
+  package: SubstreamsPackage!
+}
+
+type SubstreamsPackage {
+  moduleName: String!
+  file: String!
+}
+
+type SubstreamMapping {
+  apiVersion: String!
+  kind: String!
+}

package/src/protocols/substreams/scaffold/manifest.js

@@ -0,0 +1,13 @@
+const source = () => `
+      package:
+        moduleName: graph_out
+        file: substreams-eth-block-meta-v0.1.0.spkg`
+
+const mapping = () => `
+      apiVersion: 0.0.5
+      kind: substreams/graph-entities`
+
+module.exports = {
+  source,
+  mapping,
+}

package/src/protocols/substreams/subgraph.js

@@ -0,0 +1,17 @@
+const immutable = require('immutable')
+
+module.exports = class SubstreamsSubgraph {
+  constructor(options = {}) {
+    this.manifest = options.manifest
+    this.resolveFile = options.resolveFile
+    this.protocol = options.protocol
+  }
+
+  validateManifest() {
+    return immutable.List()
+  }
+
+  handlerTypes() {
+    return immutable.List([])
+  }
+}

package/src/scaffold/index.js

@@ -99,10 +99,15 @@ dataSources:
     )
   }
 
+  generateMappings() {
+    return this.protocol.getMappingScaffold()
+      ? { [`${strings.kebabCase(this.contractName)}.ts`]: this.generateMapping() }
+      : undefined
+  }
+
   generateMapping() {
     const hasEvents = this.protocol.hasEvents()
     const events = hasEvents ? abiEvents(this.abi).toJS() : []
-
     const protocolMapping = this.protocol.getMappingScaffold()
 
     return prettier.format(
@@ -141,7 +146,7 @@ dataSources:
       'subgraph.yaml': this.generateManifest(),
       'schema.graphql': this.generateSchema(),
       'tsconfig.json': this.generateTsConfig(),
-      src: { [`${strings.kebabCase(this.contractName)}.ts`]: this.generateMapping() },
+      src: this.generateMappings(),
       abis: this.generateABIs(),
       tests: this.generateTests(),
     }

package/src/subgraph.js

@@ -6,6 +6,8 @@ let { strOptions } = require('yaml/types')
 let graphql = require('graphql/language')
 let validation = require('./validation')
 
+let subgraphDebug = require('./debug')('graph-cli:subgraph')
+
 const throwCombinedError = (filename, errors) => {
   throw new Error(
     errors.reduce(
@@ -39,6 +41,7 @@ const buildCombinedWarning = (filename, warnings) =>
 
 module.exports = class Subgraph {
   static async validate(data, protocol, { resolveFile }) {
+    subgraphDebug(`Validating Subgraph with protocol "%s"`, protocol)
     if (protocol.name == null) {
       return immutable.fromJS([
         {
@@ -134,11 +137,19 @@ Please update it to tell users more about your subgraph.`,
       .filter(dataSource => protocol.isValidKindName(dataSource.get('kind')))
       .reduce((errors, dataSource, dataSourceIndex) => {
         let path = ['dataSources', dataSourceIndex, 'mapping']
-
         let mapping = dataSource.get('mapping')
-
         const handlerTypes = protocolSubgraph.handlerTypes()
 
+        subgraphDebug(
+          'Validating dataSource "%s" handlers with %d handlers types defined for protocol',
+          dataSource.get('name'),
+          handlerTypes.size,
+        )
+
+        if (handlerTypes.size == 0) {
+          return errors
+        }
+
         const areAllHandlersEmpty = handlerTypes
           .map(handlerType => mapping.get(handlerType, immutable.List()))
           .every(handlers => handlers.isEmpty())
@@ -159,7 +170,7 @@ At least one such handler must be defined.`,
   }
 
   static validateContractValues(manifest, protocol) {
-    if (!protocol.hasContract()){
+    if (!protocol.hasContract()) {
       return immutable.List()
     }