@graphprotocol/graph-cli 0.24.0 → 0.25.2

package/src/protocols/near/scaffold/mapping.js

@@ -0,0 +1,39 @@
+const generatePlaceholderHandlers = () =>
+  `
+  import { near, BigInt } from '@graphprotocol/graph-ts'
+  import { ExampleEntity } from '../generated/schema'
+
+  export function handleReceipt(receiptWithOutcome: near.ReceiptWithOutcome): void {
+    // Entities can be loaded from the store using a string ID; this ID
+    // needs to be unique across all entities of the same type
+    let entity = ExampleEntity.load(receiptWithOutcome.receipt.id.toHex())
+
+    // Entities only exist after they have been saved to the store;
+    // \`null\` checks allow to create entities on demand
+    if (!entity) {
+      entity = new ExampleEntity(receiptWithOutcome.receipt.id.toHex())
+
+      // Entity fields can be set using simple assignments
+      entity.count = BigInt.fromI32(0)
+    }
+
+    // BigInt and BigDecimal math are supported
+    entity.count = entity.count + BigInt.fromI32(1)
+
+    // Entity fields can be set based on receipt information
+    entity.block = receiptWithOutcome.block.header.hash
+
+    // Entities can be written to the store with \`.save()\`
+    entity.save()
+
+    // Note: If a handler doesn't require existing field values, it is faster
+    // _not_ to load the entity from the store. Instead, create it fresh with
+    // \`new Entity(...)\`, set the fields that should be updated and save the
+    // entity back to the store. Fields that were not set or unset remain
+    // unchanged, allowing for partial updates to be applied.
+  }
+`
+
+module.exports = {
+  generatePlaceholderHandlers,
+}

package/src/protocols/near/subgraph.js

@@ -1,5 +1,4 @@
 const immutable = require('immutable')
-const { validateContractValues } = require('../../validation')
 
 module.exports = class NearSubgraph {
   constructor(options = {}) {
@@ -9,28 +8,7 @@ module.exports = class NearSubgraph {
   }
 
   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`,
-    )
+    return immutable.List()
   }
 
   handlerTypes() {

package/src/{scaffold.test.js → scaffold/ethereum.test.js}

@@ -1,11 +1,7 @@
-const ABI = require('./protocols/ethereum/abi')
+const ABI = require('../protocols/ethereum/abi')
 const immutable = require('immutable')
-const {
-  generateEventFieldAssignments,
-  generateManifest,
-  generateMapping,
-  generateSchema,
-} = require('./scaffold')
+const Scaffold = require('./')
+const Protocol = require('../protocols')
 
 const TEST_EVENT = {
   name: 'ExampleEvent',
@@ -73,21 +69,33 @@ const TEST_ABI = new ABI(
   ]),
 )
 
-describe('Subgraph scaffolding', () => {
+const protocol = new Protocol('ethereum')
+
+const scaffoldOptions = {
+  protocol,
+  abi: TEST_ABI,
+  contract: '0xf87e31492faf9a91b02ee0deaad50d51d56d5d4d',
+  network: 'kovan',
+  contractName: 'Contract',
+}
+
+const scaffold = new Scaffold(scaffoldOptions)
+
+const scaffoldWithIndexEvents = new Scaffold({
+  ...scaffoldOptions,
+  indexEvents: true,
+})
+
+describe('Ethereum subgraph scaffolding', () => {
   test('Manifest', () => {
     expect(
-      generateManifest({
-        abi: TEST_ABI,
-        network: 'kovan',
-        address: '0xf87e31492faf9a91b02ee0deaad50d51d56d5d4d',
-        contractName: 'Contract'
-      }),
+      scaffold.generateManifest(),
     ).toEqual(`\
 specVersion: 0.0.1
 schema:
   file: ./schema.graphql
 dataSources:
-  - kind: ethereum/contract
+  - kind: ethereum
     name: Contract
     network: kovan
     source:
@@ -113,7 +121,7 @@ dataSources:
   })
 
   test('Schema (default)', () => {
-    expect(generateSchema({ abi: TEST_ABI })).toEqual(`\
+    expect(scaffold.generateSchema()).toEqual(`\
 type ExampleEntity @entity {
   id: ID!
   count: BigInt!
@@ -124,7 +132,7 @@ type ExampleEntity @entity {
   })
 
   test('Schema (for indexing events)', () => {
-    expect(generateSchema({ abi: TEST_ABI, indexEvents: true })).toEqual(`\
+    expect(scaffoldWithIndexEvents.generateSchema()).toEqual(`\
 type ExampleEvent @entity {
   id: ID!
   a: BigInt! # uint256
@@ -147,7 +155,7 @@ type ExampleEvent1 @entity {
   })
 
   test('Mapping (default)', () => {
-    expect(generateMapping({ abi: TEST_ABI, contractName: 'Contract' })).toEqual(`\
+    expect(scaffold.generateMapping()).toEqual(`\
 import { BigInt } from "@graphprotocol/graph-ts"
 import {
   Contract,
@@ -204,7 +212,7 @@ export function handleExampleEvent1(event: ExampleEvent1): void {}
   })
 
   test('Mapping (for indexing events)', () => {
-    expect(generateMapping({ abi: TEST_ABI, indexEvents: true, contractName: 'Contract' })).toEqual(`\
+    expect(scaffoldWithIndexEvents.generateMapping()).toEqual(`\
 import {
   ExampleEvent as ExampleEventEvent,
   ExampleEvent1 as ExampleEvent1Event

package/src/scaffold/index.js

@@ -0,0 +1,149 @@
+const prettier = require('prettier')
+const pkginfo = require('pkginfo')(module)
+
+const GRAPH_CLI_VERSION = process.env.GRAPH_CLI_TESTS
+  // JSON.stringify should remove this key, we will install the local
+  // graph-cli for the tests using `npm link` instead of fetching from npm.
+  ? undefined
+  // For scaffolding real subgraphs
+  : `${module.exports.version}`
+
+const {
+  abiEvents,
+  generateEventType,
+  generateExampleEntityType,
+} = require('./schema')
+const { generateEventIndexingHandlers } = require('./mapping')
+const { getSubgraphBasename } = require('../command-helpers/subgraph')
+
+module.exports = class Scaffold {
+  constructor(options = {}) {
+    this.protocol = options.protocol
+    this.abi = options.abi
+    this.indexEvents = options.indexEvents
+    this.contract = options.contract
+    this.network = options.network
+    this.contractName = options.contractName
+    this.subgraphName = options.subgraphName
+    this.node = options.node
+  }
+
+  generatePackageJson() {
+    return prettier.format(
+      JSON.stringify({
+        name: getSubgraphBasename(this.subgraphName),
+        license: 'UNLICENSED',
+        scripts: {
+          codegen: 'graph codegen',
+          build: 'graph build',
+          deploy:
+            `graph deploy ` +
+            `--node ${this.node} ` +
+            this.subgraphName,
+          'create-local': `graph create --node http://localhost:8020/ ${this.subgraphName}`,
+          'remove-local': `graph remove --node http://localhost:8020/ ${this.subgraphName}`,
+          'deploy-local':
+            `graph deploy ` +
+            `--node http://localhost:8020/ ` +
+            `--ipfs http://localhost:5001 ` +
+            this.subgraphName,
+        },
+        dependencies: {
+          '@graphprotocol/graph-cli': GRAPH_CLI_VERSION,
+          '@graphprotocol/graph-ts': `0.24.1`,
+        },
+      }),
+      { parser: 'json' },
+    )
+  }
+
+  generateManifest() {
+    const protocolManifest = this.protocol.getManifestScaffold()
+
+    return prettier.format(`
+specVersion: 0.0.1
+schema:
+  file: ./schema.graphql
+dataSources:
+  - kind: ${this.protocol.name}
+    name: ${this.contractName}
+    network: ${this.network}
+    source: ${protocolManifest.source(this)}
+    mapping: ${protocolManifest.mapping(this)}
+`,
+      { parser: 'yaml' },
+    )
+  }
+
+  generateSchema() {
+    const hasEvents = this.protocol.hasEvents()
+    const events = hasEvents
+      ? abiEvents(this.abi).toJS()
+      : []
+
+    return prettier.format(
+      hasEvents && this.indexEvents
+        ? events.map(
+            event => generateEventType(event, this.protocol.name)
+          )
+            .join('\n\n')
+        : generateExampleEntityType(this.protocol, events),
+      {
+        parser: 'graphql',
+      },
+    )
+  }
+
+  generateTsConfig() {
+    return prettier.format(
+      JSON.stringify({
+        extends: '@graphprotocol/graph-ts/types/tsconfig.base.json',
+        include: ['src'],
+      }),
+      { parser: 'json' },
+    )
+  }
+
+  generateMapping() {
+    const hasEvents = this.protocol.hasEvents()
+    const events = hasEvents
+      ? abiEvents(this.abi).toJS()
+      : []
+
+    const protocolMapping = this.protocol.getMappingScaffold()
+
+    return prettier.format(
+      hasEvents && this.indexEvents
+        ? generateEventIndexingHandlers(
+            events,
+            this.contractName,
+          )
+        : protocolMapping.generatePlaceholderHandlers({
+            ...this,
+            events,
+          }),
+      { parser: 'typescript', semi: false },
+    )
+  }
+
+  generateABIs() {
+    return this.protocol.hasABIs()
+      ? {
+        [`${this.contractName}.json`]: prettier.format(JSON.stringify(this.abi.data), {
+          parser: 'json',
+        }),
+      }
+      : undefined
+  }
+
+  generate() {
+    return {
+      'package.json': this.generatePackageJson(),
+      'subgraph.yaml': this.generateManifest(),
+      'schema.graphql': this.generateSchema(),
+      'tsconfig.json': this.generateTsConfig(),
+      src: { 'mapping.ts': this.generateMapping() },
+      abis: this.generateABIs(),
+    }
+  }
+}

package/src/scaffold/mapping.js

@@ -0,0 +1,49 @@
+const path = require('path')
+
+const util = require('../codegen/util')
+
+const generateFieldAssignment = path =>
+  `entity.${path.join('_')} = event.params.${path.join('.')}`
+
+const generateFieldAssignments = ({ index, input }) =>
+  input.type === 'tuple'
+    ? util
+        .unrollTuple({ value: input, index, path: [input.name || `param${index}`] })
+        .map(({ path }) => generateFieldAssignment(path))
+    : generateFieldAssignment([input.name || `param${index}`])
+
+const generateEventFieldAssignments = event =>
+  event.inputs.reduce(
+    (acc, input, index) => acc.concat(generateFieldAssignments({ input, index })),
+    [],
+  )
+
+const generateEventIndexingHandlers = (events, contractName) =>
+  `
+  import { ${events.map(
+    event => `${event._alias} as ${event._alias}Event`,
+  )}} from '../generated/${contractName}/${contractName}'
+  import { ${events.map(event => event._alias)} } from '../generated/schema'
+
+  ${events
+    .map(
+      event =>
+        `
+  export function handle${event._alias}(event: ${event._alias}Event): void {
+    let entity = new ${
+      event._alias
+    }(event.transaction.hash.toHex() + '-' + event.logIndex.toString())
+    ${generateEventFieldAssignments(event).join('\n')}
+    entity.save()
+  }
+    `,
+    )
+    .join('\n')}
+`
+
+module.exports = {
+  generateFieldAssignment,
+  generateFieldAssignments,
+  generateEventFieldAssignments,
+  generateEventIndexingHandlers,
+}

package/src/scaffold/near.test.js

@@ -0,0 +1,89 @@
+const immutable = require('immutable')
+const Scaffold = require('./')
+const Protocol = require('../protocols')
+
+const protocol = new Protocol('near')
+
+const scaffoldOptions = {
+  protocol,
+  contract: 'abc.def.near',
+  network: 'near-mainnet',
+  contractName: 'Contract',
+}
+
+const scaffold = new Scaffold(scaffoldOptions)
+
+describe('NEAR subgraph scaffolding', () => {
+  test('Manifest', () => {
+    expect(
+      scaffold.generateManifest(),
+    ).toEqual(`\
+specVersion: 0.0.1
+schema:
+  file: ./schema.graphql
+dataSources:
+  - kind: near
+    name: Contract
+    network: near-mainnet
+    source:
+      account: "abc.def.near"
+    mapping:
+      apiVersion: 0.0.5
+      language: wasm/assemblyscript
+      entities:
+        - ExampleEntity
+      receiptHandlers:
+        - handler: handleReceipt
+      file: ./src/mapping.ts
+`)
+  })
+
+  test('Schema (default)', () => {
+    expect(scaffold.generateSchema()).toEqual(`\
+type ExampleEntity @entity {
+  id: ID!
+  block: Bytes!
+  count: BigInt!
+}
+`)
+  })
+
+  test('Mapping (default)', () => {
+    expect(scaffold.generateMapping()).toEqual(`\
+import { near, BigInt } from "@graphprotocol/graph-ts"
+import { ExampleEntity } from "../generated/schema"
+
+export function handleReceipt(
+  receiptWithOutcome: near.ReceiptWithOutcome
+): void {
+  // Entities can be loaded from the store using a string ID; this ID
+  // needs to be unique across all entities of the same type
+  let entity = ExampleEntity.load(receiptWithOutcome.receipt.id.toHex())
+
+  // Entities only exist after they have been saved to the store;
+  // \`null\` checks allow to create entities on demand
+  if (!entity) {
+    entity = new ExampleEntity(receiptWithOutcome.receipt.id.toHex())
+
+    // Entity fields can be set using simple assignments
+    entity.count = BigInt.fromI32(0)
+  }
+
+  // BigInt and BigDecimal math are supported
+  entity.count = entity.count + BigInt.fromI32(1)
+
+  // Entity fields can be set based on receipt information
+  entity.block = receiptWithOutcome.block.header.hash
+
+  // Entities can be written to the store with \`.save()\`
+  entity.save()
+
+  // Note: If a handler doesn't require existing field values, it is faster
+  // _not_ to load the entity from the store. Instead, create it fresh with
+  // \`new Entity(...)\`, set the fields that should be updated and save the
+  // entity back to the store. Fields that were not set or unset remain
+  // unchanged, allowing for partial updates to be applied.
+}
+`)
+  })
+})

package/src/scaffold/schema.js

@@ -0,0 +1,62 @@
+const { ascTypeForProtocol, valueTypeForAsc } = require('../codegen/types')
+const util = require('../codegen/util')
+
+const abiEvents = abi =>
+  util.disambiguateNames({
+    values: abi.data.filter(item => item.get('type') === 'event'),
+    getName: event => event.get('name'),
+    setName: (event, name) => event.set('_alias', name),
+  })
+
+const protocolTypeToGraphQL = (protocol, name) => {
+  let ascType = ascTypeForProtocol(protocol, name)
+  return valueTypeForAsc(ascType)
+}
+
+const generateField = ({ name, type, protocolName }) =>
+  `${name}: ${protocolTypeToGraphQL(protocolName, type)}! # ${type}`
+
+const generateEventFields = ({ index, input, protocolName }) =>
+  input.type == 'tuple'
+    ? util
+        .unrollTuple({ value: input, path: [input.name || `param${index}`], index })
+        .map(({ path, type }) => generateField({ name: path.join('_'), type, protocolName }))
+    : [generateField({ name: input.name || `param${index}`, type: input.type, protocolName })]
+
+const generateEventType = (event, protocolName) => `type ${event._alias} @entity {
+      id: ID!
+      ${event.inputs
+        .reduce(
+          (acc, input, index) => acc.concat(generateEventFields({ input, index, protocolName })),
+          [],
+        )
+        .join('\n')}
+    }`
+
+const generateExampleEntityType = (protocol, events) => {
+    if (protocol.hasABIs() && events.length > 0) {
+      return `type ExampleEntity @entity {
+  id: ID!
+  count: BigInt!
+  ${events[0].inputs
+    .reduce((acc, input, index) => acc.concat(generateEventFields({ input, index, protocolName: protocol.name })), [])
+    .slice(0, 2)
+    .join('\n')}
+}`
+    } else {
+      return `type ExampleEntity @entity {
+  id: ID!
+  block: Bytes!
+  count: BigInt!
+}`
+    }
+}
+
+module.exports = {
+  abiEvents,
+  protocolTypeToGraphQL,
+  generateField,
+  generateEventFields,
+  generateEventType,
+  generateExampleEntityType,
+}

package/src/subgraph.js

@@ -145,6 +145,13 @@ At least one such handler must be defined.`,
       }, immutable.List())
   }
 
+  static validateContractValues(manifest, protocol) {
+    return validation.validateContractValues(
+      manifest,
+      protocol,
+    )
+  }
+
   // Validate that data source names are unique, so they don't overwrite each other.
   static validateUniqueDataSourceNames(manifest) {
     let names = []
@@ -231,6 +238,7 @@ More than one template named '${name}', template names must be unique.`,
       ? immutable.List()
       : immutable.List.of(
           ...protocolSubgraph.validateManifest(),
+          ...Subgraph.validateContractValues(manifest, protocol),
           ...Subgraph.validateUniqueDataSourceNames(manifest),
           ...Subgraph.validateUniqueTemplateNames(manifest),
           ...Subgraph.validateHandlers(manifest, protocol, protocolSubgraph),

package/src/validation/contract.js

@@ -0,0 +1,56 @@
+const immutable = require('immutable')
+
+const validateContract = (value, ProtocolContract) => {
+  const contract = new ProtocolContract(value)
+
+  const { valid, error } = contract.validate()
+
+  if (!valid) {
+    return {
+      valid,
+      error: `Contract ${ProtocolContract.identifierName()} is invalid: ${value}\n${error}`,
+    }
+  }
+
+  return { valid, error }
+}
+
+const validateContractValues = (manifest, protocol) => {
+  const ProtocolContract = protocol.getContract()
+
+  const fieldName = ProtocolContract.identifierName()
+
+  return manifest
+    .get('dataSources')
+    .filter(dataSource => protocol.isValidKindName(dataSource.get('kind')))
+    .reduce((errors, dataSource, dataSourceIndex) => {
+      let path = ['dataSources', dataSourceIndex, 'source', fieldName]
+
+      // No need to validate if the source has no contract field
+      if (!dataSource.get('source').has(fieldName)) {
+        return errors
+      }
+
+      let contractValue = dataSource.getIn(['source', fieldName])
+
+
+      const { valid, error } = validateContract(contractValue, ProtocolContract)
+
+      // Validate whether the contract is valid for the protocol
+      if (valid) {
+        return errors
+      } else {
+        return errors.push(
+          immutable.fromJS({
+            path,
+            message: error,
+          }),
+        )
+      }
+    }, immutable.List())
+}
+
+module.exports = {
+  validateContract,
+  validateContractValues,
+}

package/src/validation/index.js

@@ -1,5 +1,6 @@
 module.exports = {
   validateSchema: require('./schema').validateSchema,
   validateManifest: require('./manifest').validateManifest,
-  validateContractValues: require('./manifest').validateContractValues,
+  validateContractValues: require('./contract').validateContractValues,
+  validateContract: require('./contract').validateContract,
 }

package/src/validation/manifest.js

@@ -282,35 +282,6 @@ const validateManifest = (value, type, schema, protocol, { resolveFile }) => {
   return validateDataSourceNetworks(value, protocol)
 }
 
-const validateContractValues = (manifest, protocol, fieldName, validator, errorMessage) =>
-  manifest
-    .get('dataSources')
-    .filter(dataSource => protocol.isValidKindName(dataSource.get('kind')))
-    .reduce((errors, dataSource, dataSourceIndex) => {
-      let path = ['dataSources', dataSourceIndex, 'source', fieldName]
-
-      // No need to validate if the source has no contract field
-      if (!dataSource.get('source').has(fieldName)) {
-        return errors
-      }
-
-      let contractValue = dataSource.getIn(['source', fieldName])
-
-      // Validate whether the contract is valid
-      if (validator(contractValue)) {
-        return errors
-      } else {
-        return errors.push(
-          immutable.fromJS({
-            path,
-            message: `\
-Contract ${fieldName} is invalid: ${contractValue}${errorMessage ? `\n${errorMessage}` : ''}`,
-          }),
-        )
-      }
-    }, immutable.List())
-
 module.exports = {
   validateManifest,
-  validateContractValues,
 }

package/tests/cli/init/{from-contract-with-abi-and-structs.stderr → ethereum/from-contract-with-abi-and-structs.stderr}

@@ -1,5 +1,5 @@
 - Create subgraph scaffold
-  Generate subgraph from ABI
+  Generate subgraph
 - Create subgraph scaffold
   Write subgraph to directory
 - Create subgraph scaffold

package/tests/cli/init/{from-contract-with-abi.stderr → ethereum/from-contract-with-abi.stderr}

@@ -1,5 +1,5 @@
 - Create subgraph scaffold
-  Generate subgraph from ABI
+  Generate subgraph
 - Create subgraph scaffold
   Write subgraph to directory
 - Create subgraph scaffold

package/tests/cli/init/{from-contract-with-overloaded-elements.stderr → ethereum/from-contract-with-overloaded-elements.stderr}

@@ -1,5 +1,5 @@
 - Create subgraph scaffold
-  Generate subgraph from ABI
+  Generate subgraph
 - Create subgraph scaffold
   Write subgraph to directory
 - Create subgraph scaffold