@graphprotocol/graph-cli 0.25.2 → 0.27.0

package/src/codegen/schema.test.js

@@ -0,0 +1,368 @@
+const prettier = require('prettier')
+const graphql = require('graphql/language')
+const immutable = require('immutable')
+const SchemaCodeGenerator = require('./schema')
+const {
+  Class,
+  Method,
+  StaticMethod,
+  Param,
+  NamedType,
+  NullableType,
+  ArrayType,
+} = require('./typescript')
+
+const formatTS = code =>
+  prettier.format(
+    code,
+    { parser: 'typescript', semi: false }
+  )
+
+const createSchemaCodeGen = schema =>
+  new SchemaCodeGenerator({
+    ast: immutable.fromJS(graphql.parse(schema)),
+  })
+
+const testEntity = (generatedTypes, expectedEntity) => {
+  const entity = generatedTypes.find(type => type.name === expectedEntity.name)
+
+  expect(entity instanceof Class).toBe(true)
+  expect(entity.extends).toBe('Entity')
+  expect(entity.export).toBe(true)
+
+  const { members, methods } = entity
+
+  expect(members).toStrictEqual(expectedEntity.members)
+
+  for (const expectedMethod of expectedEntity.methods) {
+    const method = methods.find(method => method.name === expectedMethod.name)
+
+    expectedMethod.static
+      ? expect(method instanceof StaticMethod).toBe(true)
+      : expect(method instanceof Method).toBe(true)
+
+    expect(method.params).toStrictEqual(expectedMethod.params)
+    expect(method.returnType).toStrictEqual(expectedMethod.returnType)
+    expect(formatTS(method.body)).toBe(formatTS(expectedMethod.body))
+  }
+
+  expect(methods.length).toBe(expectedEntity.methods.length)
+}
+
+describe('Schema code generator', () => {
+  test('Should generate nothing for non entity types', () => {
+    const codegen = createSchemaCodeGen(`
+      type Foo {
+        foobar: Int
+      }
+
+      type Bar {
+        barfoo: Int
+      }
+    `)
+
+    expect(codegen.generateTypes().size).toBe(0)
+  })
+
+  describe('Should generate correct classes for each entity', () => {
+    const codegen = createSchemaCodeGen(`
+      # just to be sure nothing will be generated from non-entity types alongside regular ones
+      type Foo {
+        foobar: Int
+      }
+
+      type Account @entity {
+        id: ID!
+
+        # two non primitive types
+        description: String
+        name: String!
+
+        # two primitive types (i32)
+        age: Int
+        count: Int!
+
+        # derivedFrom
+        wallets: [Wallet!] @derivedFrom(field: "account")
+      }
+
+      type Wallet @entity {
+        id: ID!
+        amount: BigInt!
+        account: Account!
+      }
+    `)
+
+    const generatedTypes = codegen.generateTypes()
+
+    test('Foo is NOT an entity', () => {
+      const foo = generatedTypes.find(type => type.name === 'Foo')
+      expect(foo).toBe(undefined)
+      // Account and Wallet
+      expect(generatedTypes.size).toBe(2)
+    })
+
+    test('Account is an entity with the correct methods', () => {
+      testEntity(generatedTypes, {
+        name: 'Account',
+        members: [],
+        methods: [
+          {
+            name: 'constructor',
+            params: [new Param('id', new NamedType('string'))],
+            returnType: undefined,
+            body: `
+              super()
+              this.set('id', Value.fromString(id))
+
+              this.set('name', Value.fromString(''))
+              this.set('count', Value.fromI32(0))
+            `,
+          },
+          {
+            name: 'save',
+            params: [],
+            returnType: new NamedType('void'),
+            body: `
+              let id = this.get('id')
+              assert(id != null, 'Cannot save Account entity without an ID')
+              if (id) {
+                assert(
+                  id.kind == ValueKind.STRING,
+                  'Cannot save Account entity with non-string ID. ' +
+                  'Considering using .toHex() to convert the "id" to a string.'
+                )
+                store.set('Account', id.toString(), this)
+              }
+            `,
+          },
+          {
+            name: 'load',
+            static: true,
+            params: [new Param('id', new NamedType('string'))],
+            returnType: new NullableType(new NamedType('Account')),
+            body: `
+              return changetype<Account | null>(store.get('Account', id))
+            `,
+          },
+          {
+            name: 'get id',
+            params: [],
+            returnType: new NamedType('string'),
+            body: `
+              let value = this.get('id')
+              return value!.toString()
+            `,
+          },
+          {
+            name: 'set id',
+            params: [new Param('value', new NamedType('string'))],
+            returnType: undefined,
+            body: `
+              this.set('id', Value.fromString(value))
+            `,
+          },
+          {
+            name: 'get description',
+            params: [],
+            returnType: new NullableType(new NamedType('string')),
+            body: `
+              let value = this.get('description')
+              if (!value || value.kind == ValueKind.NULL) {
+                return null
+              } else {
+                return value.toString()
+              }
+            `,
+          },
+          {
+            name: 'set description',
+            params: [new Param('value', new NullableType(new NamedType('string')))],
+            returnType: undefined,
+            body: `
+              if (!value) {
+                this.unset('description')
+              } else {
+                this.set('description', Value.fromString(<string>value))
+              }
+            `,
+          },
+          {
+            name: 'get name',
+            params: [],
+            returnType: new NamedType('string'),
+            body: `
+              let value = this.get('name')
+              return value!.toString()
+            `,
+          },
+          {
+            name: 'set name',
+            params: [new Param('value', new NamedType('string'))],
+            returnType: undefined,
+            body: `
+              this.set('name', Value.fromString(value))
+            `,
+          },
+          {
+            name: 'get age',
+            params: [],
+            returnType: new NamedType('i32'),
+            body: `
+              let value = this.get('age')
+              return value!.toI32()
+            `,
+          },
+          {
+            name: 'set age',
+            params: [new Param('value', new NamedType('i32'))],
+            returnType: undefined,
+            body: `
+              this.set('age', Value.fromI32(value))
+            `,
+          },
+          {
+            name: 'get count',
+            params: [],
+            returnType: new NamedType('i32'),
+            body: `
+              let value = this.get('count')
+              return value!.toI32()
+            `,
+          },
+          {
+            name: 'set count',
+            params: [new Param('value', new NamedType('i32'))],
+            returnType: undefined,
+            body: `
+              this.set('count', Value.fromI32(value))
+            `,
+          },
+          {
+            name: 'get wallets',
+            params: [],
+            returnType: new NullableType(new ArrayType(new NamedType('string'))),
+            body: `
+              let value = this.get('wallets')
+              if (!value || value.kind == ValueKind.NULL) {
+                return null
+              } else {
+                return value.toStringArray()
+              }
+            `,
+          },
+          {
+            name: 'set wallets',
+            params: [new Param('value', new NullableType(new ArrayType(new NamedType('string'))))],
+            returnType: undefined,
+            body: `
+              if (!value) {
+                this.unset('wallets')
+              } else {
+                this.set('wallets', Value.fromStringArray(<Array<string>>value))
+              }
+            `,
+          },
+        ],
+      })
+    })
+
+    test('Wallet is an entity with the correct methods', () => {
+      testEntity(generatedTypes, {
+        name: 'Wallet',
+        members: [],
+        methods: [
+          {
+            name: 'constructor',
+            params: [new Param('id', new NamedType('string'))],
+            returnType: undefined,
+            body: `
+              super()
+              this.set('id', Value.fromString(id))
+    
+              this.set('amount', Value.fromBigInt(BigInt.zero()))
+              this.set('account', Value.fromString(''))
+            `,
+          },
+          {
+            name: 'save',
+            params: [],
+            returnType: new NamedType('void'),
+            body: `
+              let id = this.get('id')
+              assert(id != null, 'Cannot save Wallet entity without an ID')
+              if (id) {
+                assert(
+                  id.kind == ValueKind.STRING,
+                  'Cannot save Wallet entity with non-string ID. ' +
+                  'Considering using .toHex() to convert the "id" to a string.'
+                )
+                store.set('Wallet', id.toString(), this)
+              }
+            `,
+          },
+          {
+            name: 'load',
+            static: true,
+            params: [new Param('id', new NamedType('string'))],
+            returnType: new NullableType(new NamedType('Wallet')),
+            body: `
+              return changetype<Wallet | null>(store.get('Wallet', id))
+            `,
+          },
+          {
+            name: 'get id',
+            params: [],
+            returnType: new NamedType('string'),
+            body: `
+              let value = this.get('id')
+              return value!.toString()
+            `,
+          },
+          {
+            name: 'set id',
+            params: [new Param('value', new NamedType('string'))],
+            returnType: undefined,
+            body: `
+              this.set('id', Value.fromString(value))
+            `,
+          },
+          {
+            name: 'get amount',
+            params: [],
+            returnType: new NamedType('BigInt'),
+            body: `
+              let value = this.get('amount')
+              return value!.toBigInt()
+            `,
+          },
+          {
+            name: 'set amount',
+            params: [new Param('value', new NamedType('BigInt'))],
+            returnType: undefined,
+            body: `
+              this.set('amount', Value.fromBigInt(value))
+            `,
+          },
+          {
+            name: 'get account',
+            params: [],
+            returnType: new NamedType('string'),
+            body: `
+              let value = this.get('account')
+              return value!.toString()
+            `,
+          },
+          {
+            name: 'set account',
+            params: [new Param('value', new NamedType('string'))],
+            returnType: undefined,
+            body: `
+              this.set('account', Value.fromString(value))
+            `,
+          },
+        ],
+      })
+    })
+  })
+})

package/src/codegen/typescript.js

@@ -12,17 +12,6 @@ class Param {
   }
 }
 
-class ReturnType {
-  constructor(name, type) {
-    this.name = name
-    this.type = type
-  }
-
-  toString() {
-    return `${this.type.toString()}`
-  }
-}
-
 class Method {
   constructor(name, params, returnType, body) {
     this.name = name
@@ -185,8 +174,15 @@ const GENERATED_FILE_NOTE = `
 
 module.exports = {
   // Types
+  Param,
+  Method,
+  StaticMethod,
+  Class,
+  ClassMember,
+  NamedType,
   NullableType,
   ArrayType,
+  ModuleImports,
 
   // Code generators
   namedType,

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.')
 }