@graphprotocol/graph-cli 0.26.0 → 0.27.1

package/package.json

@@ -1,41 +1,44 @@
 {
   "name": "@graphprotocol/graph-cli",
-  "version": "0.26.0",
+  "version": "0.27.1",
+  "license": "(Apache-2.0 OR MIT)",
   "description": "CLI for building for and deploying to The Graph",
   "dependencies": {
     "assemblyscript": "0.19.10",
     "binary-install-raw": "0.0.13",
-    "chalk": "^3.0.0",
-    "chokidar": "^3.0.2",
-    "debug": "^4.1.1",
-    "docker-compose": "^0.23.2",
-    "dockerode": "^2.5.8",
-    "fs-extra": "^9.0.0",
-    "glob": "^7.1.2",
+    "chalk": "3.0.0",
+    "chokidar": "3.5.1",
+    "debug": "4.1.1",
+    "docker-compose": "0.23.4",
+    "dockerode": "2.5.8",
+    "fs-extra": "9.0.0",
+    "glob": "7.1.6",
     "gluegun": "https://github.com/edgeandnode/gluegun#v4.3.1-pin-colors-dep",
-    "graphql": "^15.5.0",
-    "immutable": "^3.8.2",
-    "ipfs-http-client": "^34.0.0",
-    "jayson": "^3.0.2",
-    "js-yaml": "^3.13.1",
-    "node-fetch": "^2.3.0",
-    "pkginfo": "^0.4.1",
-    "prettier": "^1.13.5",
-    "request": "^2.88.0",
+    "graphql": "15.5.0",
+    "immutable": "3.8.2",
+    "ipfs-http-client": "34.0.0",
+    "jayson": "3.2.0",
+    "js-yaml": "3.13.1",
+    "node-fetch": "2.6.0",
+    "pkginfo": "0.4.1",
+    "prettier": "1.19.1",
+    "request": "2.88.2",
     "semver": "7.3.5",
-    "tmp-promise": "^3.0.2",
+    "sync-request": "6.1.0",
+    "tmp-promise": "3.0.2",
+    "web3-eth-abi": "1.7.0",
     "which": "2.0.2",
-    "yaml": "^1.5.1"
+    "yaml": "1.9.2"
   },
   "bin": {
     "graph": "bin/graph"
   },
   "devDependencies": {
-    "eslint": "^6.0.1",
-    "jest": "^26.0.0",
-    "spawn-command": "^0.0.2-1",
-    "strip-ansi": "^6.0.0",
-    "tern": "^0.24.0"
+    "eslint": "6.8.0",
+    "jest": "26.0.0",
+    "spawn-command": "0.0.2-1",
+    "strip-ansi": "6.0.0",
+    "tern": "0.24.3"
   },
   "scripts": {
     "test": "jest --verbose",

package/src/codegen/schema.js

@@ -54,7 +54,7 @@ module.exports = class SchemaCodeGenerator {
     let klass = tsCodegen.klass(name, { export: true, extends: 'Entity' })
 
     // Generate and add a constructor
-    klass.addMethod(this._generateConstructor(name, def.get('fields')))
+    klass.addMethod(this._generateConstructor(name))
 
     // Generate and add save() and getById() methods
     this._generateStoreMethods(name).forEach(method => klass.addMethod(method))
@@ -71,42 +71,7 @@ module.exports = class SchemaCodeGenerator {
     return klass
   }
 
-  // Fields that are non-nullable get an empty/zero value set in the class constructor.
-  _generateDefaultFieldValues(fields) {
-    const indexOfIdField = fields.findIndex(field => field.getIn(['name', 'value']) === 'id')
-    const fieldsWithoutId = fields.remove(indexOfIdField)
-
-    const fieldsSetCalls = fieldsWithoutId
-      .map(field => {
-        const name = field.getIn(['name', 'value'])
-        const type = this._typeFromGraphQl(field.get('type'), true, true)
-
-        const isNullable = type instanceof tsCodegen.NullableType
-
-        const directives = field.get('directives')
-        const isDerivedFrom = directives.some(directive => directive.getIn(['name', 'value']) === 'derivedFrom')
-
-        return { name, type, isNullable, isDerivedFrom }
-      })
-      // We only call the setter with the default value in the constructor for fields that are:
-      // - Not nullable, so that AS doesn't break when subgraph developers try to access them before a `set`
-      //   - It doesn't matter if it's primitive or not
-      // - Not tagged as `derivedFrom`, because they only exist in query time
-      .filter(({
-        isNullable,
-        isDerivedFrom,
-      }) => !isNullable && !isDerivedFrom)
-      .map(({ name, type, isNullable }) => {
-        const fieldTypeString = isNullable ? type.inner.toString() : type.toString()
-
-        return `
-        this.set('${name}', ${typesCodegen.initializedValueFromAsc(fieldTypeString)})`
-      })
-
-    return fieldsSetCalls.join('')
-  }
-
-  _generateConstructor(entityName, fields) {
+  _generateConstructor(entityName) {
     return tsCodegen.method(
       'constructor',
       [tsCodegen.param('id', tsCodegen.namedType('string'))],
@@ -114,7 +79,6 @@ module.exports = class SchemaCodeGenerator {
       `
       super()
       this.set('id', Value.fromString(id))
-      ${this._generateDefaultFieldValues(fields)}
       `,
     )
   }
@@ -234,7 +198,7 @@ Suggestion: add an '!' to the member type of the List, change from '${fieldValue
       : gqlType.getIn(['name', 'value'])
   }
 
-  _typeFromGraphQl(gqlType, nullable = true, nullablePrimitive = false) {
+  _typeFromGraphQl(gqlType, nullable = true) {
     if (gqlType.get('kind') === 'NonNullType') {
       return this._typeFromGraphQl(gqlType.get('type'), false)
     } else if (gqlType.get('kind') === 'ListType') {
@@ -245,13 +209,8 @@ Suggestion: add an '!' to the member type of the List, change from '${fieldValue
       let type = tsCodegen.namedType(
         typesCodegen.ascTypeForValue(gqlType.getIn(['name', 'value'])),
       )
-
-      // Will not wrap primitives into NullableType by default.
-      if (!nullablePrimitive && type.isPrimitive()) {
-        return type
-      }
-
-      return nullable ? tsCodegen.nullableType(type) : type
+      // In AssemblyScript, primitives cannot be nullable.
+      return nullable && !type.isPrimitive() ? tsCodegen.nullableType(type) : type
     }
   }
 }

package/src/codegen/schema.test.js

@@ -114,9 +114,6 @@ describe('Schema code generator', () => {
             body: `
               super()
               this.set('id', Value.fromString(id))
-
-              this.set('name', Value.fromString(''))
-              this.set('count', Value.fromI32(0))
             `,
           },
           {
@@ -279,9 +276,6 @@ describe('Schema code generator', () => {
             body: `
               super()
               this.set('id', Value.fromString(id))
-    
-              this.set('amount', Value.fromBigInt(BigInt.zero()))
-              this.set('account', Value.fromString(''))
             `,
           },
           {

package/src/codegen/types/conversions.js

@@ -188,28 +188,28 @@ const VALUE_TO_ASSEMBLYSCRIPT = [
 const ASSEMBLYSCRIPT_TO_VALUE = [
   // Arrays
 
-  ['Array<Address>', '[Bytes]', code => `Value.fromBytesArray(${code})`, 'new Array(0)'],
-  ['Array<Bytes>', '[Bytes]', code => `Value.fromBytesArray(${code})`, 'new Array(0)'],
-  ['Array<boolean>', '[Boolean]', code => `Value.fromBooleanArray(${code})`, 'new Array(0)'],
-  ['Array<i32>', '[Int]', code => `Value.fromI32Array(${code})`, 'new Array(0)'],
-  ['Array<BigInt>', '[BigInt]', code => `Value.fromBigIntArray(${code})`, 'new Array(0)'],
-  ['Array<string>', '[String]', code => `Value.fromStringArray(${code})`, 'new Array(0)'],
-  ['Array<string>', '[ID]', code => `Value.fromStringArray(${code})`, 'new Array(0)'],
-  ['Array<BigDecimal>', '[BigDecimal]', code => `Value.fromBigDecimalArray(${code})`, 'new Array(0)'],
-  ['Array<string>', /\[.*\]/, code => `Value.fromStringArray(${code})`, 'new Array(0)'],
-  ['Array<string | null>', null, code => `Value.fromStringArray(${code})`, 'new Array(0)'],
+  ['Array<Address>', '[Bytes]', code => `Value.fromBytesArray(${code})`],
+  ['Array<Bytes>', '[Bytes]', code => `Value.fromBytesArray(${code})`],
+  ['Array<boolean>', '[Boolean]', code => `Value.fromBooleanArray(${code})`],
+  ['Array<i32>', '[Int]', code => `Value.fromI32Array(${code})`],
+  ['Array<BigInt>', '[BigInt]', code => `Value.fromBigIntArray(${code})`],
+  ['Array<string>', '[String]', code => `Value.fromStringArray(${code})`],
+  ['Array<string>', '[ID]', code => `Value.fromStringArray(${code})`],
+  ['Array<BigDecimal>', '[BigDecimal]', code => `Value.fromBigDecimalArray(${code})`],
+  ['Array<string>', /\[.*\]/, code => `Value.fromStringArray(${code})`],
+  ['Array<string | null>', null, code => `Value.fromStringArray(${code})`],
 
   // Scalar values
 
-  ['Address', 'Bytes', code => `Value.fromBytes(${code})`, 'Address.zero()'],
-  ['Bytes', 'Bytes', code => `Value.fromBytes(${code})`, 'Bytes.empty()'],
-  ['boolean', 'Boolean', code => `Value.fromBoolean(${code})`, 'false'],
-  ['i32', 'Int', code => `Value.fromI32(${code})`, '0'],
-  ['BigInt', 'BigInt', code => `Value.fromBigInt(${code})`, 'BigInt.zero()'],
-  ['string', 'String', code => `Value.fromString(${code})`, "''"],
-  ['string', 'ID', code => `Value.fromString(${code})`, "''"],
-  ['BigDecimal', 'BigDecimal', code => `Value.fromBigDecimal(${code})`, 'BigDecimal.zero()'],
-  ['string', /.*/, code => `Value.fromString(${code})`, "''"],
+  ['Address', 'Bytes', code => `Value.fromBytes(${code})`],
+  ['Bytes', 'Bytes', code => `Value.fromBytes(${code})`],
+  ['boolean', 'Boolean', code => `Value.fromBoolean(${code})`],
+  ['i32', 'Int', code => `Value.fromI32(${code})`],
+  ['BigInt', 'BigInt', code => `Value.fromBigInt(${code})`],
+  ['string', 'String', code => `Value.fromString(${code})`],
+  ['string', 'ID', code => `Value.fromString(${code})`],
+  ['BigDecimal', 'BigDecimal', code => `Value.fromBigDecimal(${code})`],
+  ['string', /.*/, code => `Value.fromString(${code})`],
 ]
 
 /**

package/src/codegen/types/index.js

@@ -66,27 +66,6 @@ const findConversionToType = (fromTypeSystem, toTypeSystem, toType) => {
   return objectifyConversion(fromTypeSystem, toTypeSystem, conversion)
 }
 
-const findInitializationForType = (fromTypeSystem, toTypeSystem, ascType) => {
-  const conversions = conversionsForTypeSystems(fromTypeSystem, toTypeSystem)
-
-  const conversion = conversions.find(conversion =>
-    typeof conversion.get(0) === 'string'
-      ? conversion.get(0) === ascType
-      : ascType.match(conversion.get(0)),
-  )
-
-  if (conversion === undefined) {
-    throw new Error(
-      `Conversion from '${fromTypeSystem}' to '${toTypeSystem}' for ` +
-        `target type '${ascType}' is not supported`,
-    )
-  }
-
-  const conversionObj = objectifyConversion(fromTypeSystem, toTypeSystem, conversion)
-
-  return conversionObj.get('convert')(conversion.get(3))
-}
-
 // High-level type system API
 
 const ascTypeForProtocol = (protocol, protocolType) =>
@@ -120,9 +99,6 @@ const valueToAsc = (code, valueType) =>
 const valueFromAsc = (code, valueType) =>
   findConversionToType('AssemblyScript', 'Value', valueType).get('convert')(code)
 
-const initializedValueFromAsc = ascType =>
-  findInitializationForType('AssemblyScript', 'Value', ascType)
-
 module.exports = {
   // protocol <-> AssemblyScript
   ascTypeForProtocol,
@@ -138,5 +114,4 @@ module.exports = {
   valueTypeForAsc,
   valueToAsc,
   valueFromAsc,
-  initializedValueFromAsc,
 }

package/src/codegen/types/index.test.js

@@ -449,26 +449,4 @@ describe('AssemblyScript -> Value', () => {
     expect(codegen.valueFromAsc('x', '[String]')).toBe('Value.fromStringArray(x)')
     expect(codegen.valueTypeForAsc('Array<string>')).toBe('[String]')
   })
-
-  describe('Initialization for zero/empty values', () => {
-    test('Array<string>', () => {
-      expect(codegen.initializedValueFromAsc('Array<string>')).toBe('Value.fromStringArray(new Array(0))')
-    })
-
-    test('Array<string | null>', () => {
-      expect(codegen.initializedValueFromAsc('Array<string | null>')).toBe('Value.fromStringArray(new Array(0))')
-    })
-
-    test('i32', () => {
-      expect(codegen.initializedValueFromAsc('i32')).toBe('Value.fromI32(0)')
-    })
-
-    test('string', () => {
-      expect(codegen.initializedValueFromAsc('string')).toBe("Value.fromString('')")
-    })
-
-    test('BigInt', () => {
-      expect(codegen.initializedValueFromAsc('BigInt')).toBe('Value.fromBigInt(BigInt.zero())')
-    })
-  })
 })

package/src/commands/deploy.js

@@ -30,6 +30,7 @@ Options:
   -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)
@@ -96,6 +97,7 @@ module.exports = {
       skipMigrations,
       w,
       watch,
+      debugFork,
     } = toolbox.parameters.options
 
     // Support both long and short option variants
@@ -264,7 +266,7 @@ module.exports = {
       //       `Failed to deploy to Graph node ${requestUrl}`,
       client.request(
         'subgraph_deploy',
-        { name: subgraphName, ipfs_hash: ipfsHash, version_label: versionLabel },
+        { name: subgraphName, ipfs_hash: ipfsHash, version_label: versionLabel, debug_fork: debugFork },
         async (requestError, jsonRpcError, res) => {
           if (jsonRpcError) {
             spinner.fail(

package/src/commands/init.js

@@ -283,6 +283,8 @@ const getEtherscanLikeAPIUrl = (network) => {
     case "bsc": return `https://api.bscscan.com/api`;
     case "matic": return `https://api.polygonscan.com/api`;
     case "mumbai": return `https://api-testnet.polygonscan.com/api`;
+    case "aurora": return `https://api.aurorascan.dev/api`;
+    case "aurora-testnet": return `https://api-testnet.aurorascan.dev/api`;
     default: return `https://api-${network}.etherscan.io/api`;
   }
 } 

package/src/commands/test.js

@@ -2,8 +2,9 @@ const { Binary } = require('binary-install-raw')
 const os = require('os')
 const chalk = require('chalk')
 const fetch = require('node-fetch')
-const { filesystem, print } = require('gluegun')
+const { filesystem, patching, print, system } = require('gluegun')
 const { fixParameters } = require('../command-helpers/gluegun')
+const path = require('path')
 const semver = require('semver')
 const { spawn, exec } = require('child_process')
 const yaml = require('js-yaml')
@@ -102,7 +103,7 @@ async function runBinary(datasource, opts) {
   let latestVersion = opts.get("latestVersion")
   let recompileOpt = opts.get("recompile")
 
-  const platform = getPlatform(logsOpt)
+  const platform = await getPlatform(logsOpt)
 
   const url = `https://github.com/LimeChain/matchstick/releases/download/${versionOpt || latestVersion}/${platform}`
 
@@ -120,19 +121,21 @@ async function runBinary(datasource, opts) {
   args.length > 0 ? binary.run(...args) : binary.run()
 }
 
-function getPlatform(logsOpt) {
+async function getPlatform(logsOpt) {
   const type = os.type()
   const arch = os.arch()
-  const release = os.release()
   const cpuCore = os.cpus()[0]
-  const majorVersion = semver.major(release)
-  const isM1 = cpuCore.model.includes("Apple M1")
+  const isM1 = (arch === 'arm64' && /Apple (M1|processor)/.test(cpuCore.model))
+  const linuxInfo = type === 'Linux' ? await getLinuxInfo() : new Map()
+  const linuxDistro = linuxInfo.get('name')
+  const release = linuxInfo.get('version') || os.release()
+  const majorVersion = parseInt(linuxInfo.get('version'), 10) || semver.major(release)
 
   if (logsOpt) {
-    print.info(`OS type: ${type}\nOS arch: ${arch}\nOS release: ${release}\nOS major version: ${majorVersion}\nCPU model: ${cpuCore.model}`)
+    print.info(`OS type: ${linuxDistro || type}\nOS arch: ${arch}\nOS release: ${release}\nOS major version: ${majorVersion}\nCPU model: ${cpuCore.model}`)
   }
 
-  if (arch === 'x64' || (arch === 'arm64' && isM1)) {
+  if (arch === 'x64' || isM1) {
     if (type === 'Darwin') {
       if (majorVersion === 19) {
         return 'binary-macos-10.15'
@@ -145,8 +148,9 @@ function getPlatform(logsOpt) {
     } else if (type === 'Linux') {
       if (majorVersion === 18) {
         return 'binary-linux-18'
+      } else {
+        return 'binary-linux-20'
       }
-      return 'binary-linux-20'
     } else if (type === 'Windows_NT') {
       return 'binary-windows'
     }
@@ -155,6 +159,23 @@ function getPlatform(logsOpt) {
   throw new Error(`Unsupported platform: ${type} ${arch} ${majorVersion}`)
 }
 
+async function getLinuxInfo() {
+  try {
+    let result = await system.run("cat /etc/*-release | grep -E '(^VERSION|^NAME)='", {trim: true})
+    let infoArray = result.replace(/['"]+/g, '').split('\n').map(p => p.split('='))
+    let infoMap = new Map();
+
+    infoArray.forEach((val) => {
+      infoMap.set(val[0].toLowerCase(), val[1])
+    });
+
+    return infoMap
+  } catch (error) {
+    print.error(`Error fetching the Linux version:\n ${error}`)
+    process.exit(1)
+  }
+}
+
 async function runDocker(datasource, opts) {
   let coverageOpt = opts.get("coverage")
   let forceOpt = opts.get("force")
@@ -169,27 +190,34 @@ async function runDocker(datasource, opts) {
   // Get current working directory
   let current_folder = await filesystem.cwd()
 
-  // Build the Dockerfile location. Defaults to ./tests/.docker if
-  // a custom testsFolder is not declared in the subgraph.yaml
-  let dockerDir = ""
+  // Declate dockerfilePath with default location
+  let dockerfilePath = "./tests/.docker/Dockerfile"
 
-  try {
-    let doc = await yaml.load(filesystem.read('subgraph.yaml', 'utf8'))
-    testsFolder = doc.testsFolder || './tests'
-    dockerDir = testsFolder.endsWith('/') ? testsFolder + '.docker' : testsFolder + '/.docker'
-  } catch (error) {
-    print.error(error.message)
-    return
+  // Check if matchstick.yaml config exists
+  if(filesystem.exists('matchstick.yaml')) {
+    try {
+      // Load the config
+      let config = await yaml.load(filesystem.read('matchstick.yaml', 'utf8'))
+
+      // Check if matchstick.yaml is not empty
+      if(config != null) {
+        // If a custom tests folder is declared update dockerfilePath
+        dockerfilePath = path.join(config.testsFolder || 'tests', '.docker/Dockerfile')
+      }
+    } catch (error) {
+      print.info('A problem occurred while reading matchstick.yaml. Please attend to the errors below:')
+      print.error(error.message)
+      process.exit(1)
+    }
   }
 
-  // Create the Dockerfile
-  try {
-    await filesystem.write(`${dockerDir}/Dockerfile`, dockerfile(versionOpt, latestVersion))
-    print.info('Successfully generated Dockerfile.')
-  } catch (error) {
-    print.info('A problem occurred while generating the Dockerfile. Please attend to the errors below:')
-    print.error(error.message)
-    return
+  // Check if the Dockerfil already exists
+  let dockerfileExists = filesystem.exists(dockerfilePath)
+
+  // Generate the Dockerfile only if it doesn't exists,
+  // version flag and/or force flag is passed.
+  if(!dockerfileExists || versionOpt || forceOpt) {
+    await dockerfile(dockerfilePath, versionOpt, latestVersion)
   }
 
   // Run a command to check if matchstick image already exists
@@ -212,10 +240,10 @@ async function runDocker(datasource, opts) {
 
     // If a matchstick image does not exists, the command returns an empty string,
     // else it'll return the image ID. Skip `docker build` if an image already exists
-    // If `-v/--version` is specified, delete current image(if any) and rebuild.
+    // Delete current image(if any) and rebuild.
     // Use spawn() and {stdio: 'inherit'} so we can see the logs in real time.
-    if(stdout === '' || versionOpt || forceOpt) {
-      if ((stdout !== '' && versionOpt) || forceOpt) {
+    if(!dockerfileExists || stdout === '' || versionOpt || forceOpt) {
+      if (stdout !== '') {
         exec('docker image rm matchstick', (error, stdout, stderr) => {
           print.info(chalk.bold(`Removing matchstick image\n${stdout}`))
         })
@@ -224,7 +252,7 @@ async function runDocker(datasource, opts) {
       // run a container from that image.
       spawn(
         'docker',
-        ['build', '--no-cache', '-f', `${dockerDir}/Dockerfile`, '-t', 'matchstick', '.'],
+        ['build', '-f', dockerfilePath, '-t', 'matchstick', '.'],
         { stdio: 'inherit' }
       ).on('close', code => {
         if (code === 0) {
@@ -239,37 +267,32 @@ async function runDocker(datasource, opts) {
   })
 }
 
-// TODO: Move these in separate file (in a function maybe)
-function dockerfile(versionOpt, latestVersion) {
-  return `
-  FROM ubuntu:20.04
-  ENV ARGS=""
-
-  # Install necessary packages
-  RUN apt update
-  RUN apt install -y nodejs
-  RUN apt install -y npm
-  RUN apt install -y git
-  RUN apt install -y postgresql
-  RUN apt install -y curl
-  RUN apt install -y cmake
-  RUN npm install -g @graphprotocol/graph-cli
+// Downloads Dockerfile template from the demo-subgraph repo
+// Replaces the placeholders with their respective values
+async function dockerfile(dockerfilePath, versionOpt, latestVersion) {
+  let spinner = print.spin("Generating Dockerfile...")
 
-  # Download the latest linux binary
-  RUN curl -OL https://github.com/LimeChain/matchstick/releases/download/${versionOpt || latestVersion}/binary-linux-20
-
-  # Make it executable
-  RUN chmod a+x binary-linux-20
+  try {
+    // Fetch the Dockerfile template content from the demo-subgraph repo
+    let content = await fetch('https://raw.githubusercontent.com/LimeChain/demo-subgraph/main/Dockerfile')
+        .then((response) => {
+          if (response.ok) {
+            return response.text()
+          } else {
+            throw new Error(`Status Code: ${response.status}, with error: ${response.statusText}`);
+          }
+        })
 
-  # Create a matchstick dir where the host will be copied
-  RUN mkdir matchstick
-  WORKDIR matchstick
+    // Write the Dockerfile
+    await filesystem.write(dockerfilePath, content)
 
-  # Copy host to /matchstick
-  COPY ../ .
+    // Replaces the version placeholders
+    await patching.replace(dockerfilePath, '<MATCHSTICK_VERSION>', versionOpt || latestVersion)
 
-  RUN graph codegen
-  RUN graph build
+  } catch (error) {
+    spinner.fail(`A problem occurred while generating the Dockerfile. Please attend to the errors below:\n ${error.message}`)
+    process.exit(1)
+  }
 
-  CMD ../binary-linux-20 \${ARGS}`
+  spinner.succeed('Successfully generated Dockerfile.')
 }