@graphprotocol/graph-cli 0.22.2 → 0.23.0

package/src/subgraph.js

@@ -5,7 +5,6 @@ let yaml = require('yaml')
 let { strOptions } = require('yaml/types')
 let graphql = require('graphql/language')
 let validation = require('./validation')
-let ABI = require('./abi')
 
 const throwCombinedError = (filename, errors) => {
   throw new Error(
@@ -39,7 +38,7 @@ const buildCombinedWarning = (filename, warnings) =>
     : null
 
 module.exports = class Subgraph {
-  static async validate(data, { resolveFile }) {
+  static async validate(data, protocol, { resolveFile }) {
     // Parse the default subgraph schema
     let schema = graphql.parse(
       await fs.readFile(path.join(__dirname, '..', 'manifest-schema.graphql'), 'utf-8'),
@@ -51,7 +50,7 @@ module.exports = class Subgraph {
     })
 
     // Validate the subgraph manifest using this schema
-    return validation.validateManifest(data, rootType, schema, { resolveFile })
+    return validation.validateManifest(data, rootType, schema, protocol, { resolveFile })
   }
 
   static validateSchema(manifest, { resolveFile }) {
@@ -88,235 +87,6 @@ module.exports = class Subgraph {
     }
   }
 
-  static collectDataSources(manifest) {
-    return manifest
-      .get('dataSources')
-      .reduce(
-        (dataSources, dataSource, dataSourceIndex) =>
-          dataSource.get('kind') === 'ethereum/contract'
-            ? dataSources.push(
-                immutable.Map({ path: ['dataSources', dataSourceIndex], dataSource }),
-              )
-            : dataSources,
-        immutable.List(),
-      )
-  }
-
-  static collectDataSourceTemplates(manifest) {
-    return manifest.get('templates', immutable.List()).reduce(
-      (templates, template, templateIndex) =>
-        template.get('kind') === 'ethereum/contract'
-          ? templates.push(
-              immutable.Map({
-                path: ['templates', templateIndex],
-                dataSource: template,
-              }),
-            )
-          : templates,
-      immutable.List(),
-    )
-  }
-
-  static validateDataSourceAbis(dataSource, { resolveFile, path }) {
-    // Validate that the the "source > abi" reference of all data sources
-    // points to an existing ABI in the data source ABIs
-    let abiName = dataSource.getIn(['source', 'abi'])
-    let abiNames = dataSource.getIn(['mapping', 'abis']).map(abi => abi.get('name'))
-    let nameErrors = abiNames.includes(abiName)
-      ? immutable.List()
-      : immutable.fromJS([
-          {
-            path: [...path, 'source', 'abi'],
-            message: `\
-ABI name '${abiName}' not found in mapping > abis.
-Available ABIs:
-${abiNames
-  .sort()
-  .map(name => `- ${name}`)
-  .join('\n')}`,
-          },
-        ])
-
-    // Validate that all ABI files are valid
-    let fileErrors = dataSource
-      .getIn(['mapping', 'abis'])
-      .reduce((errors, abi, abiIndex) => {
-        try {
-          ABI.load(abi.get('name'), resolveFile(abi.get('file')))
-          return errors
-        } catch (e) {
-          return errors.push(
-            immutable.fromJS({
-              path: [...path, 'mapping', 'abis', abiIndex, 'file'],
-              message: e.message,
-            }),
-          )
-        }
-      }, immutable.List())
-
-    return nameErrors.concat(fileErrors)
-  }
-
-  static validateAbis(manifest, { resolveFile }) {
-    let dataSources = Subgraph.collectDataSources(manifest)
-    let dataSourceTemplates = Subgraph.collectDataSourceTemplates(manifest)
-
-    return dataSources.concat(dataSourceTemplates).reduce(
-      (errors, dataSourceOrTemplate) =>
-        errors.concat(
-          Subgraph.validateDataSourceAbis(dataSourceOrTemplate.get('dataSource'), {
-            resolveFile,
-            path: dataSourceOrTemplate.get('path'),
-          }),
-        ),
-      immutable.List(),
-    )
-  }
-
-  static validateContractAddresses(manifest) {
-    return manifest
-      .get('dataSources')
-      .filter(dataSource => dataSource.get('kind') === 'ethereum/contract')
-      .reduce((errors, dataSource, dataSourceIndex) => {
-        let path = ['dataSources', dataSourceIndex, 'source', 'address']
-
-        // No need to validate if the source has no contract address
-        if (!dataSource.get('source').has('address')) {
-          return errors
-        }
-
-        let address = dataSource.getIn(['source', 'address'])
-
-        // Validate whether the address is valid
-        let pattern = /^(0x)?[0-9a-fA-F]{40}$/
-        if (pattern.test(address)) {
-          return errors
-        } else {
-          return errors.push(
-            immutable.fromJS({
-              path,
-              message: `\
-Contract address is invalid: ${address}
-Must be 40 hexadecimal characters, with an optional '0x' prefix.`,
-            }),
-          )
-        }
-      }, immutable.List())
-  }
-
-  static validateDataSourceEvents(dataSource, { resolveFile, path }) {
-    let abi
-    try {
-      // Resolve the source ABI name into a real ABI object
-      let abiName = dataSource.getIn(['source', 'abi'])
-      let abiEntry = dataSource
-        .getIn(['mapping', 'abis'])
-        .find(abi => abi.get('name') === abiName)
-      abi = ABI.load(abiEntry.get('name'), resolveFile(abiEntry.get('file')))
-    } catch (_) {
-      // Ignore errors silently; we can't really say anything about
-      // the events if the ABI can't even be loaded
-      return immutable.List()
-    }
-
-    // Obtain event signatures from the mapping
-    let manifestEvents = dataSource
-      .getIn(['mapping', 'eventHandlers'], immutable.List())
-      .map(handler => handler.get('event'))
-
-    // Obtain event signatures from the ABI
-    let abiEvents = abi.eventSignatures()
-
-    // Add errors for every manifest event signature that is not
-    // present in the ABI
-    return manifestEvents.reduce(
-      (errors, manifestEvent, index) =>
-        abiEvents.includes(manifestEvent)
-          ? errors
-          : errors.push(
-              immutable.fromJS({
-                path: [...path, 'eventHandlers', index],
-                message: `\
-Event with signature '${manifestEvent}' not present in ABI '${abi.name}'.
-Available events:
-${abiEvents
-  .sort()
-  .map(event => `- ${event}`)
-  .join('\n')}`,
-              }),
-            ),
-      immutable.List(),
-    )
-  }
-
-  static validateEvents(manifest, { resolveFile }) {
-    let dataSources = Subgraph.collectDataSources(manifest)
-    let dataSourceTemplates = Subgraph.collectDataSourceTemplates(manifest)
-
-    return dataSources
-      .concat(dataSourceTemplates)
-      .reduce((errors, dataSourceOrTemplate) => {
-        return errors.concat(
-          Subgraph.validateDataSourceEvents(dataSourceOrTemplate.get('dataSource'), {
-            resolveFile,
-            path: dataSourceOrTemplate.get('path'),
-          }),
-        )
-      }, immutable.List())
-  }
-
-  static validateCallFunctions(manifest, { resolveFile }) {
-    return manifest
-      .get('dataSources')
-      .filter(dataSource => dataSource.get('kind') === 'ethereum/contract')
-      .reduce((errors, dataSource, dataSourceIndex) => {
-        let path = ['dataSources', dataSourceIndex, 'callHandlers']
-
-        let abi
-        try {
-          // Resolve the source ABI name into a real ABI object
-          let abiName = dataSource.getIn(['source', 'abi'])
-          let abiEntry = dataSource
-            .getIn(['mapping', 'abis'])
-            .find(abi => abi.get('name') === abiName)
-          abi = ABI.load(abiEntry.get('name'), resolveFile(abiEntry.get('file')))
-        } catch (e) {
-          // Ignore errors silently; we can't really say anything about
-          // the call functions if the ABI can't even be loaded
-          return errors
-        }
-
-        // Obtain event signatures from the mapping
-        let manifestFunctions = dataSource
-          .getIn(['mapping', 'callHandlers'], immutable.List())
-          .map(handler => handler.get('function'))
-
-        // Obtain event signatures from the ABI
-        let abiFunctions = abi.callFunctionSignatures()
-
-        // Add errors for every manifest event signature that is not
-        // present in the ABI
-        return manifestFunctions.reduce(
-          (errors, manifestFunction, index) =>
-            abiFunctions.includes(manifestFunction)
-              ? errors
-              : errors.push(
-                  immutable.fromJS({
-                    path: [...path, index],
-                    message: `\
-Call function with signature '${manifestFunction}' not present in ABI '${abi.name}'.
-Available call functions:
-${abiFunctions
-  .sort()
-  .map(tx => `- ${tx}`)
-  .join('\n')}`,
-                  }),
-                ),
-          errors,
-        )
-      }, immutable.List())
-  }
-
   static validateRepository(manifest, { resolveFile }) {
     return manifest.get('repository') !==
       'https://github.com/graphprotocol/example-subgraph'
@@ -332,9 +102,9 @@ Please replace it with a link to your subgraph source code.`,
   }
 
   static validateDescription(manifest, { resolveFile }) {
-    return manifest.get('description') !== 'Gravatar for Ethereum'
-      ? immutable.List()
-      : immutable.List().push(
+    // TODO: Maybe implement this in the future for each protocol example description
+    return manifest.get('description', '').startsWith('Gravatar for ')
+      ? immutable.List().push(
           immutable.fromJS({
             path: ['description'],
             message: `\
@@ -342,28 +112,32 @@ The description is still the one from the example subgraph.
 Please update it to tell users more about your subgraph.`,
           }),
         )
+      : immutable.List()
   }
 
-  static validateEthereumContractHandlers(manifest) {
+  static validateHandlers(manifest, protocol, protocolSubgraph) {
     return manifest
       .get('dataSources')
-      .filter(dataSource => dataSource.get('kind') === 'ethereum/contract')
+      .filter(dataSource => protocol.isValidKindName(dataSource.get('kind')))
       .reduce((errors, dataSource, dataSourceIndex) => {
         let path = ['dataSources', dataSourceIndex, 'mapping']
 
         let mapping = dataSource.get('mapping')
-        let blockHandlers = mapping.get('blockHandlers', immutable.List())
-        let callHandlers = mapping.get('callHandlers', immutable.List())
-        let eventHandlers = mapping.get('eventHandlers', immutable.List())
 
-        return blockHandlers.isEmpty() &&
-          callHandlers.isEmpty() &&
-          eventHandlers.isEmpty()
+        const handlerTypes = protocolSubgraph.handlerTypes()
+
+        const areAllHandlersEmpty = handlerTypes
+          .map(handlerType => mapping.get(handlerType, immutable.List()))
+          .every(handlers => handlers.isEmpty())
+
+        const handlerNamesWithoutLast = handlerTypes.pop().join(', ')
+
+        return areAllHandlersEmpty
           ? errors.push(
               immutable.fromJS({
                 path: path,
                 message: `\
-Mapping has no blockHandlers, callHandlers or eventHandlers.
+Mapping has no ${handlerNamesWithoutLast} or ${handlerTypes.get(-1)}.
 At least one such handler must be defined.`,
               }),
             )
@@ -419,7 +193,10 @@ More than one template named '${name}', template names must be unique.`,
     return yaml.stringify(manifest.toJS())
   }
 
-  static async load(filename, { skipValidation } = { skipValidation: false }) {
+  static async load(
+    filename,
+    { protocol, skipValidation } = { skipValidation: false }
+  ) {
     // Load and validate the manifest
     let data = null
 
@@ -434,7 +211,7 @@ More than one template named '${name}', template names must be unique.`,
     let resolveFile = maybeRelativeFile =>
       path.resolve(path.dirname(filename), maybeRelativeFile)
 
-    let manifestErrors = await Subgraph.validate(data, { resolveFile })
+    let manifestErrors = await Subgraph.validate(data, protocol, { resolveFile })
     if (manifestErrors.size > 0) {
       throwCombinedError(filename, manifestErrors)
     }
@@ -445,16 +222,18 @@ More than one template named '${name}', template names must be unique.`,
     Subgraph.validateSchema(manifest, { resolveFile })
 
     // Perform other validations
+    const protocolSubgraph = protocol.getSubgraph({
+      manifest,
+      resolveFile,
+    })
+
     let errors = skipValidation
       ? immutable.List()
       : immutable.List.of(
-          ...Subgraph.validateAbis(manifest, { resolveFile }),
-          ...Subgraph.validateContractAddresses(manifest),
-          ...Subgraph.validateEthereumContractHandlers(manifest),
-          ...Subgraph.validateEvents(manifest, { resolveFile }),
-          ...Subgraph.validateCallFunctions(manifest, { resolveFile }),
+          ...protocolSubgraph.validateManifest(),
           ...Subgraph.validateUniqueDataSourceNames(manifest),
           ...Subgraph.validateUniqueTemplateNames(manifest),
+          ...Subgraph.validateHandlers(manifest, protocol, protocolSubgraph),
         )
 
     if (errors.size > 0) {
@@ -467,7 +246,6 @@ More than one template named '${name}', template names must be unique.`,
       : immutable.List.of(
           ...Subgraph.validateRepository(manifest, { resolveFile }),
           ...Subgraph.validateDescription(manifest, { resolveFile }),
-          ...Subgraph.validateEthereumContractHandlers(manifest),
         )
 
     return {

package/src/type-generator.js

@@ -6,17 +6,14 @@ const graphql = require('graphql/language')
 const chalk = require('chalk')
 const toolbox = require('gluegun/toolbox')
 
-const ABI = require('./abi')
 const Schema = require('./schema')
 const Subgraph = require('./subgraph')
 const DataSourceTemplateCodeGenerator = require('./codegen/template')
 const Watcher = require('./watcher')
 const { step, withSpinner } = require('./command-helpers/spinner')
 const { applyMigrations } = require('./migrations')
-
-const GENERATED_FILE_NOTE = `
-// THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
-`
+const { GENERATED_FILE_NOTE } = require('./codegen/typescript')
+const { displayPath } = require('./command-helpers/fs')
 
 module.exports = class TypeGenerator {
   constructor(options) {
@@ -25,15 +22,17 @@ module.exports = class TypeGenerator {
       this.options.sourceDir ||
       (this.options.subgraphManifest && path.dirname(this.options.subgraphManifest))
 
+    this.protocol = this.options.protocol
+    this.protocolTypeGenerator = this.protocol.getTypeGenerator({
+      sourceDir: this.sourceDir,
+      outputDir: this.options.outputDir,
+    })
+
     process.on('uncaughtException', function(e) {
       toolbox.print.error(`UNCAUGHT EXCEPTION: ${e}`)
     })
   }
 
-  displayPath(p) {
-    return path.relative(process.cwd(), p)
-  }
-
   async generateTypes() {
     try {
       if (!this.options.skipMigrations && this.options.subgraphManifest) {
@@ -43,13 +42,20 @@ module.exports = class TypeGenerator {
         })
       }
       let subgraph = await this.loadSubgraph()
-      let abis = await this.loadABIs(subgraph)
-      await this.generateTypesForABIs(abis)
+
+      // Not all protocols support/have ABIs.
+      if (this.protocol.hasABIs()) {
+        const abis = await this.protocolTypeGenerator.loadABIs(subgraph)
+        await this.protocolTypeGenerator.generateTypesForABIs(abis)
+      }
 
       await this.generateTypesForDataSourceTemplates(subgraph)
 
-      let templateAbis = await this.loadDataSourceTemplateABIs(subgraph)
-      await this.generateTypesForDataSourceTemplateABIs(templateAbis)
+      // Not all protocols support/have ABIs.
+      if (this.protocol.hasABIs()) {
+        const templateAbis = await this.protocolTypeGenerator.loadDataSourceTemplateABIs(subgraph)
+        await this.protocolTypeGenerator.generateTypesForDataSourceTemplateABIs(templateAbis)
+      }
 
       let schema = await this.loadSchema(subgraph)
       await this.generateTypesForSchema(schema)
@@ -62,12 +68,14 @@ module.exports = class TypeGenerator {
   }
 
   async loadSubgraph({ quiet } = { quiet: false }) {
+    const subgraphLoadOptions = { protocol: this.protocol, skipValidation: false }
+
     if (quiet) {
       return this.options.subgraph
         ? this.options.subgraph
-        : Subgraph.load(this.options.subgraphManifest).result
+        : Subgraph.load(this.options.subgraphManifest, subgraphLoadOptions).result
     } else {
-      const manifestPath = this.displayPath(this.options.subgraphManifest)
+      const manifestPath = displayPath(this.options.subgraphManifest)
 
       return await withSpinner(
         `Load subgraph from ${manifestPath}`,
@@ -76,167 +84,19 @@ module.exports = class TypeGenerator {
         async spinner => {
           return this.options.subgraph
             ? this.options.subgraph
-            : Subgraph.load(this.options.subgraphManifest)
+            : Subgraph.load(this.options.subgraphManifest, subgraphLoadOptions)
         },
       )
     }
   }
 
-  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`, this.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}`)
-    }
-  }
-
-  _loadDataSourceTemplateABI(template, name, maybeRelativePath, spinner) {
-    try {
-      if (this.sourceDir) {
-        let absolutePath = path.resolve(this.sourceDir, maybeRelativePath)
-        step(
-          spinner,
-          `Load data source template ABI from`,
-          this.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} (${this.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.options.outputDir,
-        abi.dataSource.get('name'),
-        `${abi.abi.name}.ts`,
-      )
-      step(spinner, `Write types to`, this.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 _generateTypesForDataSourceTemplateABI(abi, spinner) {
-    try {
-      step(
-        spinner,
-        `Generate types for data source template ABI:`,
-        `${abi.template.get('name')} > ${abi.abi.name} (${this.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.options.outputDir,
-        'templates',
-        abi.template.get('name'),
-        `${abi.abi.name}.ts`,
-      )
-      step(spinner, `Write types to`, this.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}`)
-    }
-  }
-
   async loadSchema(subgraph) {
     let maybeRelativePath = subgraph.getIn(['schema', 'file'])
     let absolutePath = path.resolve(this.sourceDir, maybeRelativePath)
     return await withSpinner(
-      `Load GraphQL schema from ${this.displayPath(absolutePath)}`,
-      `Failed to load GraphQL schema from ${this.displayPath(absolutePath)}`,
-      `Warnings while loading GraphQL schema from ${this.displayPath(absolutePath)}`,
+      `Load GraphQL schema from ${displayPath(absolutePath)}`,
+      `Failed to load GraphQL schema from ${displayPath(absolutePath)}`,
+      `Warnings while loading GraphQL schema from ${displayPath(absolutePath)}`,
       async spinner => {
         let maybeRelativePath = subgraph.getIn(['schema', 'file'])
         let absolutePath = path.resolve(this.sourceDir, maybeRelativePath)
@@ -265,7 +125,7 @@ module.exports = class TypeGenerator {
         )
 
         let outputFile = path.join(this.options.outputDir, 'schema.ts')
-        step(spinner, 'Write types to', this.displayPath(outputFile))
+        step(spinner, 'Write types to', displayPath(outputFile))
         await fs.mkdirs(path.dirname(outputFile))
         await fs.writeFile(outputFile, code)
       },
@@ -288,7 +148,7 @@ module.exports = class TypeGenerator {
               `${template.get('name')}`,
             )
 
-            let codeGenerator = new DataSourceTemplateCodeGenerator(template)
+            let codeGenerator = new DataSourceTemplateCodeGenerator(template, this.protocol)
 
             // Only generate module imports once, because they are identical for
             // all types generated for data source templates.
@@ -305,7 +165,7 @@ module.exports = class TypeGenerator {
           })
 
           let outputFile = path.join(this.options.outputDir, 'templates.ts')
-          step(spinner, `Write types for templates to`, this.displayPath(outputFile))
+          step(spinner, `Write types for templates to`, displayPath(outputFile))
           await fs.mkdirs(path.dirname(outputFile))
           await fs.writeFile(outputFile, code)
         }
@@ -313,46 +173,6 @@ module.exports = class TypeGenerator {
     )
   }
 
-  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
-      },
-    )
-  }
-
-  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 getFilesToWatch() {
     try {
       let files = []
@@ -387,7 +207,7 @@ module.exports = class TypeGenerator {
       onReady: () => (spinner = toolbox.print.spin('Watching subgraph files')),
       onTrigger: async changedFile => {
         if (changedFile !== undefined) {
-          spinner.info(`File change detected: ${this.displayPath(changedFile)}\n`)
+          spinner.info(`File change detected: ${displayPath(changedFile)}\n`)
         }
         await generator.generateTypes()
         spinner.start()