@graphprotocol/graph-cli 0.37.2 → 0.37.3-alpha-20230110163550-d64bef6

package/src/scaffold/tests.js

@@ -1,34 +1,39 @@
-const prettier = require('prettier')
-const { strings } = require('gluegun')
-const { ascTypeForEthereum, ethereumFromAsc } = require("../codegen/types")
+import prettier from 'prettier'
+import { strings } from 'gluegun'
+import { ascTypeForEthereum, ethereumFromAsc } from '../codegen/types'
 
 const VARIABLES_VALUES = {
-  "i32": 123,
-  "BigInt": 234,
-  "Bytes": 1234567890,
-  "Address": "0x0000000000000000000000000000000000000001",
-  "string": "Example string value",
-  "bool": true,
+  i32: 123,
+  BigInt: 234,
+  Bytes: 1234567890,
+  Address: '0x0000000000000000000000000000000000000001',
+  string: 'Example string value',
+  bool: true,
 }
 
 const generateTestsFiles = (contract, events, indexEvents) => {
   const eventsTypes = events
     .flatMap(event =>
-      event
-        .inputs
-        .map(input => {
-          // If the asc type is Array<T> we need to check if T is a native type or a custom graph-ts type
-          // If we don't do that we may miss a type that should be imported from graph-ts
-          const ascType = ascTypeForEthereum(input.type)
-          const inner = fetchArrayInnerType(ascType)
-          return inner ? inner[1] : ascType
-        })
-    ).filter(type => !type.startsWith("ethereum.") && !isNativeType(type))
+      event.inputs.map(input => {
+        // If the asc type is Array<T> we need to check if T is a native type or a custom graph-ts type
+        // If we don't do that we may miss a type that should be imported from graph-ts
+        const ascType = ascTypeForEthereum(input.type)
+        const inner = fetchArrayInnerType(ascType)
+        return inner ? inner[1] : ascType
+      }),
+    )
+    .filter(type => !type.startsWith('ethereum.') && !isNativeType(type))
   const importTypes = [...new Set(eventsTypes)].join(', ')
 
   return {
-    [`${strings.kebabCase(contract)}.test.ts`]: prettier.format(generateExampleTest(contract, events[0], indexEvents, importTypes), { parser: 'typescript', semi: false }),
-    [`${strings.kebabCase(contract)}-utils.ts`]: prettier.format(generateTestHelper(contract, events, importTypes), { parser: 'typescript', semi: false }),
+    [`${strings.kebabCase(contract)}.test.ts`]: prettier.format(
+      generateExampleTest(contract, events[0], indexEvents, importTypes),
+      { parser: 'typescript', semi: false },
+    ),
+    [`${strings.kebabCase(contract)}-utils.ts`]: prettier.format(
+      generateTestHelper(contract, events, importTypes),
+      { parser: 'typescript', semi: false },
+    ),
   }
 }
 
@@ -39,26 +44,28 @@ const generateTestsFiles = (contract, events, indexEvents) => {
   let displayName = "Example string value"
   let imageUrl = "Example string value"
 */
-const generateArguments = (eventInputs) => {
-  return eventInputs.map((input, index) => {
-    let ascType = ascTypeForEthereum(input.type)
-    return `let ${input.name || `param${index}`} = ${assignValue(ascType, input.name)}`
-  }).join('\n')
+const generateArguments = eventInputs => {
+  return eventInputs
+    .map((input, index) => {
+      let ascType = ascTypeForEthereum(input.type)
+      return `let ${input.name || `param${index}`} = ${assignValue(ascType, input.name)}`
+    })
+    .join('\n')
 }
 
 // Generates the value that will be assigned to a variable in generateArguments()
-const assignValue = (type) => {
+const assignValue = type => {
   switch (type) {
-    case "string":
+    case 'string':
       return `"${VARIABLES_VALUES[type]}"`
-    case "BigInt":
+    case 'BigInt':
       return `BigInt.fromI32(${VARIABLES_VALUES[type]})`
-    case "Address":
+    case 'Address':
       return `Address.fromString("${VARIABLES_VALUES[type]}")`
-    case "Bytes":
+    case 'Bytes':
       return `Bytes.fromI32(${VARIABLES_VALUES[type]})`
     case fetchArrayInnerType(type)?.input:
-      innerType = fetchArrayInnerType(type)[1]
+      const innerType = fetchArrayInnerType(type)[1]
       return `[${assignValue(innerType)}]`
     default:
       let value = VARIABLES_VALUES[type]
@@ -75,20 +82,25 @@ const assignValue = (type) => {
     "0x0000000000000000000000000000000000000001"
   )
 */
-const generateFieldsAssertions = (entity, eventInputs, indexEvents) => eventInputs.filter(input => input.name != "id").map((input, index) =>
-  `assert.fieldEquals(
+const generateFieldsAssertions = (entity, eventInputs, indexEvents) =>
+  eventInputs
+    .filter(input => input.name != 'id')
+    .map(
+      (input, index) =>
+        `assert.fieldEquals(
     "${entity}",
-    "0xa16081f360e3847006db660bae1c6d1b2e17ec2a${indexEvents ? "-1" : ""}",
+    "0xa16081f360e3847006db660bae1c6d1b2e17ec2a${indexEvents ? '-1' : ''}",
     "${input.name || `param${index}`}",
     "${expectedValue(ascTypeForEthereum(input.type))}"
-  )`
-).join('\n')
+  )`,
+    )
+    .join('\n')
 
 // Returns the expected value for a given type in generateFieldsAssertions()
 const expectedValue = type => {
   switch (type) {
     case fetchArrayInnerType(type)?.input:
-      innerType = fetchArrayInnerType(type)[1]
+      const innerType = fetchArrayInnerType(type)[1]
       return `[${expectedValue(innerType)}]`
     default:
       let value = VARIABLES_VALUES[type]
@@ -98,13 +110,9 @@ const expectedValue = type => {
 
 // Checks if the type is a native AS type or should be imported from graph-ts
 const isNativeType = type => {
-  let natives = [
-    /i32/,
-    /string/,
-    /boolean/
-  ]
+  let natives = [/i32/, /string/, /boolean/]
 
-  return natives.some(rx => rx.test(type));
+  return natives.some(rx => rx.test(type))
 }
 
 const fetchArrayInnerType = type => type.match(/Array<(.*?)>/)
@@ -119,7 +127,9 @@ const generateExampleTest = (contract, event, indexEvents, importTypes) => {
   import { assert, describe, test, clearStore, beforeAll, afterAll } from "matchstick-as/assembly/index"
   import { ${importTypes} } from "@graphprotocol/graph-ts"
   import { ${entity} } from "../generated/schema"
-  import { ${indexEvents ? `${eventName} as ${eventName}Event` : eventName} } from "../generated/${contract}/${contract}"
+  import { ${
+    indexEvents ? `${eventName} as ${eventName}Event` : eventName
+  } } from "../generated/${contract}/${contract}"
   import { handle${eventName} } from "../src/${strings.kebabCase(contract)}"
   import { create${eventName}Event } from "./${strings.kebabCase(contract)}-utils"
 
@@ -130,7 +140,9 @@ const generateExampleTest = (contract, event, indexEvents, importTypes) => {
   describe("Describe entity assertions", () => {
     beforeAll(() => {
       ${generateArguments(eventInputs)}
-      let new${eventName}Event = create${eventName}Event(${eventInputs.map((input, index) => input.name || `param${index}`).join(', ')});
+      let new${eventName}Event = create${eventName}Event(${eventInputs
+    .map((input, index) => input.name || `param${index}`)
+    .join(', ')});
       handle${eventName}(new${eventName}Event)
     })
 
@@ -161,21 +173,26 @@ const generateTestHelper = (contract, events, importTypes) => {
   return `
   import { newMockEvent } from 'matchstick-as';
   import { ethereum, ${importTypes} } from '@graphprotocol/graph-ts';
-  import { ${eventsNames.join(", ")} } from '../generated/${contract}/${contract}';
+  import { ${eventsNames.join(', ')} } from '../generated/${contract}/${contract}';
 
-  ${generateMockedEvents(events).join("\n")}`
+  ${generateMockedEvents(events).join('\n')}`
 }
 
 const generateMockedEvents = events =>
-  events.reduce(
-    (acc, event) => acc.concat(generateMockedEvent(event)),
-    [],
-  )
+  events.reduce((acc, event) => acc.concat(generateMockedEvent(event)), [])
 
 const generateMockedEvent = event => {
   const varName = `${strings.camelCase(event._alias)}Event`
-  const fnArgs = event.inputs.map((input, index) => `${input.name || `param${index}`}: ${ascTypeForEthereum(input.type)}`);
-  const ascToEth = event.inputs.map((input, index) => `${varName}.parameters.push(new ethereum.EventParam("${input.name || `param${index}`}", ${ethereumFromAsc(input.name || `param${index}`, input.type)}))`);
+  const fnArgs = event.inputs.map(
+    (input, index) =>
+      `${input.name || `param${index}`}: ${ascTypeForEthereum(input.type)}`,
+  )
+  const ascToEth = event.inputs.map(
+    (input, index) =>
+      `${varName}.parameters.push(new ethereum.EventParam("${
+        input.name || `param${index}`
+      }", ${ethereumFromAsc(input.name || `param${index}`, input.type)}))`,
+  )
 
   return `
     export function create${event._alias}Event(${fnArgs.join(', ')}): ${event._alias} {
@@ -188,9 +205,6 @@ const generateMockedEvent = event => {
       return ${varName};
     }
   `
-
 }
 
-module.exports = {
-  generateTestsFiles,
-}
+export { generateTestsFiles }

package/src/schema.ts

@@ -0,0 +1,26 @@
+import fs from 'fs-extra'
+import * as graphql from 'graphql/language'
+import immutable from 'immutable'
+import SchemaCodeGenerator from './codegen/schema'
+
+export default class Schema {
+  constructor(
+    public filename: string,
+    public document: string,
+    public ast: immutable.Collection<unknown, unknown>,
+  ) {
+    this.filename = filename
+    this.document = document
+    this.ast = ast
+  }
+
+  codeGenerator() {
+    return new SchemaCodeGenerator(this)
+  }
+
+  static async load(filename: string) {
+    let document = await fs.readFile(filename, 'utf-8')
+    let ast = graphql.parse(document)
+    return new Schema(filename, document, immutable.fromJS(ast))
+  }
+}

package/src/{subgraph.js → subgraph.ts}

@@ -1,14 +1,16 @@
-let fs = require('fs-extra')
-let immutable = require('immutable')
-let path = require('path')
-let yaml = require('yaml')
-let { strOptions } = require('yaml/types')
-let graphql = require('graphql/language')
-let validation = require('./validation')
-
-let subgraphDebug = require('./debug')('graph-cli:subgraph')
-
-const throwCombinedError = (filename, errors) => {
+import fs from 'fs-extra'
+import immutable from 'immutable'
+import path from 'path'
+import yaml from 'yaml'
+import { strOptions } from 'yaml/types'
+import * as graphql from 'graphql/language'
+import validation from './validation'
+import debug from './debug'
+import { Subgraph as ISubgraph } from './protocols/subgraph'
+
+let subgraphDebug = debug('graph-cli:subgraph')
+
+const throwCombinedError = (filename: string, errors: immutable.List<any>) => {
   throw new Error(
     errors.reduce(
       (msg, e) =>
@@ -24,7 +26,7 @@ const throwCombinedError = (filename, errors) => {
   )
 }
 
-const buildCombinedWarning = (filename, warnings) =>
+const buildCombinedWarning = (filename: string, warnings: immutable.List<any>) =>
   warnings.size > 0
     ? warnings.reduce(
         (msg, w) =>
@@ -39,8 +41,14 @@ const buildCombinedWarning = (filename, warnings) =>
       ) + '\n'
     : null
 
-module.exports = class Subgraph {
-  static async validate(data, protocol, { resolveFile }) {
+type ResolveFile = (path: string) => string
+
+export default class Subgraph {
+  static async validate(
+    data: any,
+    protocol: any,
+    { resolveFile }: { resolveFile: ResolveFile },
+  ) {
     subgraphDebug(`Validating Subgraph with protocol "%s"`, protocol)
     if (protocol.name == null) {
       return immutable.fromJS([
@@ -61,6 +69,7 @@ module.exports = class Subgraph {
 
     // Obtain the root `SubgraphManifest` type from the schema
     let rootType = schema.definitions.find(definition => {
+      // @ts-expect-error TODO: name field does not exist on definition, really?
       return definition.name.value === 'SubgraphManifest'
     })
 
@@ -68,21 +77,18 @@ module.exports = class Subgraph {
     return validation.validateManifest(data, rootType, schema, protocol, { resolveFile })
   }
 
-  static validateSchema(manifest, { resolveFile }) {
+  static validateSchema(manifest: any, { resolveFile }: { resolveFile: ResolveFile }) {
     let filename = resolveFile(manifest.getIn(['schema', 'file']))
-    let errors = validation.validateSchema(filename)
+    const validationErrors = validation.validateSchema(filename)
+    let errors: immutable.Collection<any, any>
 
-    if (errors.size > 0) {
-      errors = errors.groupBy(error => error.get('entity')).sort()
+    if (validationErrors.size > 0) {
+      errors = validationErrors.groupBy(error => error.get('entity')).sort()
       let msg = errors.reduce((msg, errors, entity) => {
-        errors = errors.groupBy(error => error.get('directive'))
-        let inner_msgs = errors.reduce((msg, errors, directive) => {
-          return `${msg}${
-            directive
-              ? `
-    ${directive}:`
-              : ''
-          }
+        errors = errors.groupBy((error: any) => error.get('directive'))
+        let inner_msgs = errors.reduce(
+          (msg: string, errors: any[], directive: string) => {
+            return `${msg}${directive ? `${directive}:` : ''}
   ${errors
     .map(error =>
       error
@@ -92,7 +98,9 @@ module.exports = class Subgraph {
     )
     .map(msg => `${directive ? '  ' : ''}- ${msg}`)
     .join('\n  ')}`
-        }, ``)
+          },
+          ``,
+        )
         return `${msg}
 
   ${entity}:${inner_msgs}`
@@ -102,7 +110,7 @@ module.exports = class Subgraph {
     }
   }
 
-  static validateRepository(manifest, { resolveFile }) {
+  static validateRepository(manifest: immutable.Collection<any, any>) {
     const repository = manifest.get('repository')
 
     return /^https:\/\/github\.com\/graphprotocol\/example-subgraphs?$/.test(repository)
@@ -117,7 +125,7 @@ Please replace it with a link to your subgraph source code.`,
       : immutable.List()
   }
 
-  static validateDescription(manifest, { resolveFile }) {
+  static validateDescription(manifest: immutable.Collection<any, any>) {
     // TODO: Maybe implement this in the future for each protocol example description
     return manifest.get('description', '').startsWith('Gravatar for ')
       ? immutable.List().push(
@@ -131,11 +139,15 @@ Please update it to tell users more about your subgraph.`,
       : immutable.List()
   }
 
-  static validateHandlers(manifest, protocol, protocolSubgraph) {
+  static validateHandlers(
+    manifest: immutable.Collection<any, any>,
+    protocol: any,
+    protocolSubgraph: ISubgraph,
+  ) {
     return manifest
       .get('dataSources')
-      .filter(dataSource => protocol.isValidKindName(dataSource.get('kind')))
-      .reduce((errors, dataSource, dataSourceIndex) => {
+      .filter((dataSource: any) => protocol.isValidKindName(dataSource.get('kind')))
+      .reduce((errors: any, dataSource: any, dataSourceIndex: any) => {
         let path = ['dataSources', dataSourceIndex, 'mapping']
         let mapping = dataSource.get('mapping')
         const handlerTypes = protocolSubgraph.handlerTypes()
@@ -151,8 +163,8 @@ Please update it to tell users more about your subgraph.`,
         }
 
         const areAllHandlersEmpty = handlerTypes
-          .map(handlerType => mapping.get(handlerType, immutable.List()))
-          .every(handlers => handlers.isEmpty())
+          .map((handlerType: any) => mapping.get(handlerType, immutable.List()))
+          .every((handlers: immutable.List<any>) => handlers.isEmpty())
 
         const handlerNamesWithoutLast = handlerTypes.pop().join(', ')
 
@@ -169,7 +181,7 @@ At least one such handler must be defined.`,
       }, immutable.List())
   }
 
-  static validateContractValues(manifest, protocol) {
+  static validateContractValues(manifest: any, protocol: any) {
     if (!protocol.hasContract()) {
       return immutable.List()
     }
@@ -178,30 +190,32 @@ At least one such handler must be defined.`,
   }
 
   // Validate that data source names are unique, so they don't overwrite each other.
-  static validateUniqueDataSourceNames(manifest) {
-    let names = []
-    return manifest.get('dataSources').reduce((errors, dataSource, dataSourceIndex) => {
-      let path = ['dataSources', dataSourceIndex, 'name']
-      let name = dataSource.get('name')
-      if (names.includes(name)) {
-        errors = errors.push(
-          immutable.fromJS({
-            path,
-            message: `\
+  static validateUniqueDataSourceNames(manifest: any) {
+    let names: any[] = []
+    return manifest
+      .get('dataSources')
+      .reduce((errors: immutable.List<any>, dataSource: any, dataSourceIndex: number) => {
+        let path = ['dataSources', dataSourceIndex, 'name']
+        let name = dataSource.get('name')
+        if (names.includes(name)) {
+          errors = errors.push(
+            immutable.fromJS({
+              path,
+              message: `\
 More than one data source named '${name}', data source names must be unique.`,
-          }),
-        )
-      }
-      names.push(name)
-      return errors
-    }, immutable.List())
+            }),
+          )
+        }
+        names.push(name)
+        return errors
+      }, immutable.List())
   }
 
-  static validateUniqueTemplateNames(manifest) {
-    let names = []
+  static validateUniqueTemplateNames(manifest: any) {
+    let names: any[] = []
     return manifest
       .get('templates', immutable.List())
-      .reduce((errors, template, templateIndex) => {
+      .reduce((errors: immutable.List<any>, template: any, templateIndex: number) => {
         let path = ['templates', templateIndex, 'name']
         let name = template.get('name')
         if (names.includes(name)) {
@@ -218,14 +232,20 @@ More than one template named '${name}', template names must be unique.`,
       }, immutable.List())
   }
 
-  static dump(manifest) {
+  static dump(manifest: any) {
     strOptions.fold.lineWidth = 90
+    // @ts-expect-error TODO: plain is the value behind the TS constant
     strOptions.defaultType = 'PLAIN'
 
     return yaml.stringify(manifest.toJS())
   }
 
-  static async load(filename, { protocol, skipValidation } = { skipValidation: false }) {
+  static async load(
+    filename: string,
+    { protocol, skipValidation }: { protocol?: any; skipValidation?: boolean } = {
+      skipValidation: false,
+    },
+  ) {
     // Load and validate the manifest
     let data = null
     let has_file_data_sources = false
@@ -239,7 +259,7 @@ More than one template named '${name}', template names must be unique.`,
     }
 
     // Helper to resolve files relative to the subgraph manifest
-    let resolveFile = maybeRelativeFile =>
+    let resolveFile: ResolveFile = maybeRelativeFile =>
       path.resolve(path.dirname(filename), maybeRelativeFile)
 
     // TODO: Validation for file data sources
@@ -279,8 +299,8 @@ More than one template named '${name}', template names must be unique.`,
     let warnings = skipValidation
       ? immutable.List()
       : immutable.List.of(
-          ...Subgraph.validateRepository(manifest, { resolveFile }),
-          ...Subgraph.validateDescription(manifest, { resolveFile }),
+          ...Subgraph.validateRepository(manifest),
+          ...Subgraph.validateDescription(manifest),
         )
 
     return {
@@ -289,7 +309,7 @@ More than one template named '${name}', template names must be unique.`,
     }
   }
 
-  static async write(manifest, filename) {
+  static async write(manifest: any, filename: string) {
     await fs.writeFile(filename, Subgraph.dump(manifest))
   }
 }

package/src/type-generator.js

@@ -1,22 +1,22 @@
-const fs = require('fs-extra')
-const immutable = require('immutable')
-const path = require('path')
-const prettier = require('prettier')
-const graphql = require('graphql/language')
-const chalk = require('chalk')
-const toolbox = require('gluegun/toolbox')
-
-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 } = require('./codegen/typescript')
-const { displayPath } = require('./command-helpers/fs')
-const uncrashable = require('@float-capital/float-subgraph-uncrashable/src/Index.bs.js')
-
-module.exports = class TypeGenerator {
+import fs from 'fs-extra'
+import immutable from 'immutable'
+import path from 'path'
+import prettier from 'prettier'
+import * as graphql from 'graphql/language'
+import chalk from 'chalk'
+import * as toolbox from 'gluegun/toolbox'
+
+import Schema from './schema'
+import Subgraph from './subgraph'
+import DataSourceTemplateCodeGenerator from './codegen/template'
+import Watcher from './watcher'
+import { step, withSpinner } from './command-helpers/spinner'
+import { applyMigrations } from './migrations'
+import { GENERATED_FILE_NOTE } from './codegen/typescript'
+import { displayPath } from './command-helpers/fs'
+import uncrashable from '@float-capital/float-subgraph-uncrashable/src/Index.bs.js'
+
+export default class TypeGenerator {
   constructor(options) {
     this.options = options || {}
     this.sourceDir =
@@ -29,7 +29,7 @@ module.exports = class TypeGenerator {
       outputDir: this.options.outputDir,
     })
 
-    process.on('uncaughtException', function(e) {
+    process.on('uncaughtException', function (e) {
       toolbox.print.error(`UNCAUGHT EXCEPTION: ${e}`)
     })
   }

package/src/validation/contract.js

@@ -1,4 +1,4 @@
-const immutable = require('immutable')
+import immutable from 'immutable'
 
 const validateContract = (value, ProtocolContract) => {
   const contract = new ProtocolContract(value)
@@ -33,7 +33,6 @@ const validateContractValues = (manifest, protocol) => {
 
       let contractValue = dataSource.getIn(['source', fieldName])
 
-
       const { valid, error } = validateContract(contractValue, ProtocolContract)
 
       // Validate whether the contract is valid for the protocol
@@ -50,7 +49,4 @@ const validateContractValues = (manifest, protocol) => {
     }, immutable.List())
 }
 
-module.exports = {
-  validateContract,
-  validateContractValues,
-}
+export { validateContract, validateContractValues }

package/src/validation/index.js

@@ -1,4 +1,4 @@
-module.exports = {
+export default {
   validateSchema: require('./schema').validateSchema,
   validateManifest: require('./manifest').validateManifest,
   validateContractValues: require('./contract').validateContractValues,