@graphprotocol/graph-cli 0.22.2 → 0.23.0

package/src/protocols/ethereum/type-generator.js

@@ -0,0 +1,203 @@
+const fs = require('fs-extra')
+const path = require('path')
+const immutable = require('immutable')
+const prettier = require('prettier')
+const ABI = require('./abi')
+const { step, withSpinner } = require('../../command-helpers/spinner')
+const { GENERATED_FILE_NOTE } = require('../../codegen/typescript')
+const { displayPath } = require('../../command-helpers/fs')
+
+module.exports = class EthereumTypeGenerator {
+  constructor(options = {}) {
+    this.sourceDir = options.sourceDir
+    this.outputDir = options.outputDir
+  }
+
+  async loadABIs(subgraph) {
+    return await withSpinner(
+      'Load contract ABIs',
+      'Failed to load contract ABIs',
+      `Warnings while loading contract ABIs`,
+      async spinner => {
+        try {
+          return subgraph
+            .get('dataSources')
+            .reduce(
+              (abis, dataSource) =>
+              dataSource
+              .getIn(['mapping', 'abis'])
+              .reduce(
+                (abis, abi) =>
+                abis.push(
+                  this._loadABI(
+                    dataSource,
+                    abi.get('name'),
+                    abi.get('file'),
+                    spinner,
+                  ),
+                ),
+                abis,
+              ),
+              immutable.List(),
+            )
+        } catch (e) {
+          throw Error(`Failed to load contract ABIs: ${e.message}`)
+        }
+      },
+    )
+  }
+
+  _loadABI(dataSource, name, maybeRelativePath, spinner) {
+    try {
+      if (this.sourceDir) {
+        let absolutePath = path.resolve(this.sourceDir, maybeRelativePath)
+        step(spinner, `Load contract ABI from`, displayPath(absolutePath))
+        return { dataSource: dataSource, abi: ABI.load(name, absolutePath) }
+      } else {
+        return { dataSource: dataSource, abi: ABI.load(name, maybeRelativePath) }
+      }
+    } catch (e) {
+      throw Error(`Failed to load contract ABI: ${e.message}`)
+    }
+  }
+
+  async loadDataSourceTemplateABIs(subgraph) {
+    return await withSpinner(
+      `Load data source template ABIs`,
+      `Failed to load data source template ABIs`,
+      `Warnings while loading data source template ABIs`,
+      async spinner => {
+        let abis = []
+        for (let template of subgraph.get('templates', immutable.List())) {
+          for (let abi of template.getIn(['mapping', 'abis'])) {
+            abis.push(
+              this._loadDataSourceTemplateABI(
+                template,
+                abi.get('name'),
+                abi.get('file'),
+                spinner,
+              ),
+            )
+          }
+        }
+        return abis
+      },
+    )
+  }
+
+  _loadDataSourceTemplateABI(template, name, maybeRelativePath, spinner) {
+    try {
+      if (this.sourceDir) {
+        let absolutePath = path.resolve(this.sourceDir, maybeRelativePath)
+        step(
+          spinner,
+          `Load data source template ABI from`,
+          displayPath(absolutePath),
+        )
+        return { template, abi: ABI.load(name, absolutePath) }
+      } else {
+        return { template, abi: ABI.load(name, maybeRelativePath) }
+      }
+    } catch (e) {
+      throw Error(`Failed to load data source template ABI: ${e.message}`)
+    }
+  }
+
+  generateTypesForABIs(abis) {
+    return withSpinner(
+      `Generate types for contract ABIs`,
+      `Failed to generate types for contract ABIs`,
+      `Warnings while generating types for contract ABIs`,
+      async spinner => {
+        return await Promise.all(
+          abis.map(async (abi, name) => await this._generateTypesForABI(abi, spinner)),
+        )
+      },
+    )
+  }
+
+  async _generateTypesForABI(abi, spinner) {
+    try {
+      step(
+        spinner,
+        `Generate types for contract ABI:`,
+        `${abi.abi.name} (${displayPath(abi.abi.file)})`,
+      )
+
+      let codeGenerator = abi.abi.codeGenerator()
+      let code = prettier.format(
+        [
+          GENERATED_FILE_NOTE,
+          ...codeGenerator.generateModuleImports(),
+          ...codeGenerator.generateTypes(),
+        ].join('\n'),
+        {
+          parser: 'typescript',
+        },
+      )
+
+      let outputFile = path.join(
+        this.outputDir,
+        abi.dataSource.get('name'),
+        `${abi.abi.name}.ts`,
+      )
+      step(spinner, `Write types to`, displayPath(outputFile))
+      await fs.mkdirs(path.dirname(outputFile))
+      await fs.writeFile(outputFile, code)
+    } catch (e) {
+      throw Error(`Failed to generate types for contract ABI: ${e.message}`)
+    }
+  }
+
+  async generateTypesForDataSourceTemplateABIs(abis) {
+    return await withSpinner(
+      `Generate types for data source template ABIs`,
+      `Failed to generate types for data source template ABIs`,
+      `Warnings while generating types for data source template ABIs`,
+      async spinner => {
+        return await Promise.all(
+          abis.map(
+            async (abi, name) =>
+              await this._generateTypesForDataSourceTemplateABI(abi, spinner),
+          ),
+        )
+      },
+    )
+  }
+
+  async _generateTypesForDataSourceTemplateABI(abi, spinner) {
+    try {
+      step(
+        spinner,
+        `Generate types for data source template ABI:`,
+        `${abi.template.get('name')} > ${abi.abi.name} (${displayPath(
+          abi.abi.file,
+        )})`,
+      )
+
+      let codeGenerator = abi.abi.codeGenerator()
+      let code = prettier.format(
+        [
+          GENERATED_FILE_NOTE,
+          ...codeGenerator.generateModuleImports(),
+          ...codeGenerator.generateTypes(),
+        ].join('\n'),
+        {
+          parser: 'typescript',
+        },
+      )
+
+      let outputFile = path.join(
+        this.outputDir,
+        'templates',
+        abi.template.get('name'),
+        `${abi.abi.name}.ts`,
+      )
+      step(spinner, `Write types to`, displayPath(outputFile))
+      await fs.mkdirs(path.dirname(outputFile))
+      await fs.writeFile(outputFile, code)
+    } catch (e) {
+      throw Error(`Failed to generate types for data source template ABI: ${e.message}`)
+    }
+  }
+}

package/src/protocols/index.js

@@ -0,0 +1,97 @@
+const immutable = require('immutable')
+const EthereumTypeGenerator = require('./ethereum/type-generator')
+const EthereumTemplateCodeGen = require('./ethereum/codegen/template')
+const EthereumABI = require('./ethereum/abi')
+const EthereumSubgraph = require('./ethereum/subgraph')
+const NearSubgraph = require('./near/subgraph')
+
+module.exports = class Protocol {
+  static fromDataSources(dataSourcesAndTemplates) {
+    const firstDataSourceKind = dataSourcesAndTemplates[0].kind
+    return new Protocol(firstDataSourceKind)
+  }
+
+  constructor(name) {
+    this.name = this.normalizeName(name)
+  }
+
+  availableProtocols() {
+    return immutable.fromJS({
+      // `ethereum/contract` is kept for backwards compatibility.
+      // New networks (or protocol perhaps) shouldn't have the `/contract` anymore (unless a new case makes use of it).
+      ethereum: ['ethereum', 'ethereum/contract'],
+      near: ['near'],
+    })
+  }
+
+  normalizeName(name) {
+    return this.availableProtocols()
+      .findKey(possibleNames => possibleNames.includes(name))
+  }
+
+  // Receives a data source kind, and checks if it's valid
+  // for the given protocol instance (this).
+  isValidKindName(kind) {
+    return this.availableProtocols()
+      .get(this.name, immutable.List())
+      .includes(kind)
+  }
+
+  hasABIs() {
+    switch (this.name) {
+      case 'ethereum':
+      case 'ethereum/contract':
+        return true
+      case 'near':
+        return false
+    }
+  }
+
+  getTypeGenerator(options) {
+    switch (this.name) {
+      case 'ethereum':
+      case 'ethereum/contract':
+        return new EthereumTypeGenerator(options)
+      case 'near':
+        return null
+    }
+  }
+
+  getTemplateCodeGen(template) {
+    switch (this.name) {
+      case 'ethereum':
+      case 'ethereum/contract':
+        return new EthereumTemplateCodeGen(template)
+      default:
+        throw new Error(
+          `Template data sources with kind '${this.name}' are not supported yet`,
+        )
+    }
+  }
+
+  getABI() {
+    switch (this.name) {
+      case 'ethereum':
+      case 'ethereum/contract':
+        return EthereumABI
+      case 'near':
+        return null
+    }
+  }
+
+  getSubgraph(options = {}) {
+    const optionsWithProtocol = { ...options, protocol: this }
+
+    switch (this.name) {
+      case 'ethereum':
+      case 'ethereum/contract':
+        return new EthereumSubgraph(optionsWithProtocol)
+      case 'near':
+        return new NearSubgraph(optionsWithProtocol)
+      default:
+        throw new Error(
+          `Data sources with kind '${this.name}' are not supported yet`,
+        )
+    }
+  }
+}

package/src/protocols/near/subgraph.js

@@ -0,0 +1,42 @@
+const immutable = require('immutable')
+const { validateContractValues } = require('../../validation')
+
+module.exports = class NearSubgraph {
+  constructor(options = {}) {
+    this.manifest = options.manifest
+    this.resolveFile = options.resolveFile
+    this.protocol = options.protocol
+  }
+
+  validateManifest() {
+    return this.validateContractAccounts()
+  }
+
+  validateContractAccounts() {
+    // Reference: https://docs.near.org/docs/concepts/account#account-id-rules
+    const MINIMUM_ACCOUNT_ID_LENGTH = 2
+    const MAXIMUM_ACCOUNT_ID_LENGTH = 64
+    const validateLength = accountId =>
+      accountId.length >= MINIMUM_ACCOUNT_ID_LENGTH &&
+      accountId.length <= MAXIMUM_ACCOUNT_ID_LENGTH
+    const nearAccountIdPattern = /^(([a-z\d]+[\-_])*[a-z\d]+\.)*([a-z\d]+[\-_])*[a-z\d]+$/
+
+    return validateContractValues(
+      this.manifest,
+      this.protocol,
+      'account',
+      accountId => validateLength(accountId) && nearAccountIdPattern.test(accountId),
+      `Must be between '${MINIMUM_ACCOUNT_ID_LENGTH}' and '${MAXIMUM_ACCOUNT_ID_LENGTH}' characters
+An Account ID consists of Account ID parts separated by '.' (dots)
+Each Account ID part consists of lowercase alphanumeric symbols separated by either a '_' (underscore) or '-' (dash)
+For further information look for: https://docs.near.org/docs/concepts/account#account-id-rules`,
+    )
+  }
+
+  handlerTypes() {
+    return immutable.List([
+      'blockHandlers',
+      'receiptHandlers',
+    ])
+  }
+}

package/src/scaffold.js

@@ -6,8 +6,9 @@ const pkginfo = require('pkginfo')(module)
 const { getSubgraphBasename } = require('./command-helpers/subgraph')
 const { step } = require('./command-helpers/spinner')
 const { ascTypeForEthereum, valueTypeForAsc } = require('./codegen/types')
-const ABI = require('./abi')
-const AbiCodeGenerator = require('./codegen/abi')
+// TODO: Use Protocol class to getABI
+const ABI = require('./protocols/ethereum/abi')
+const AbiCodeGenerator = require('./protocols/ethereum/codegen/abi')
 const util = require('./codegen/util')
 
 const abiEvents = abi =>

package/src/scaffold.test.js

@@ -1,4 +1,4 @@
-const ABI = require('./abi')
+const ABI = require('./protocols/ethereum/abi')
 const immutable = require('immutable')
 const {
   generateEventFieldAssignments,