@graphprotocol/graph-cli 0.25.3 → 0.28.0

package/src/protocols/tendermint/contract.js

@@ -0,0 +1,12 @@
+module.exports = class TendermintContract {
+  static identifierName() {
+    return 'address'
+  }
+
+  validate() {
+    return {
+      valid: true,
+      error: null,
+    }
+  }
+}

package/src/protocols/tendermint/manifest.graphql

@@ -0,0 +1,64 @@
+# Each referenced type's in any of the types below must be listed
+# here either as `scalar` or `type` for the validation code to work
+# properly.
+#
+# That's why `String` is listed as a scalar even though it's built-in
+# GraphQL basic types.
+scalar String
+scalar File
+scalar BigInt
+
+type SubgraphManifest {
+  specVersion: String!
+  schema: Schema!
+  description: String
+  repository: String
+  graft: Graft
+  dataSources: [DataSource!]!
+}
+
+type Schema {
+  file: File!
+}
+
+type DataSource {
+  kind: String!
+  name: String!
+  network: String
+  source: ContractSource!
+  mapping: ContractMapping!
+}
+
+type ContractSource {
+  startBlock: BigInt
+}
+
+type ContractMapping {
+  apiVersion: String!
+  language: String!
+  file: File!
+  entities: [String!]!
+  blockHandlers: [BlockHandler!]
+  eventHandlers: [EventHandler!]
+}
+
+type BlockHandler {
+  handler: String!
+}
+
+enum EventOrigin {
+  BeginBlock
+  DeliverTx
+  EndBlock
+}
+
+type EventHandler {
+  event: String!
+  origin: EventOrigin
+  handler: String!
+}
+
+type Graft {
+  base: String!
+  block: BigInt!
+}

package/src/protocols/tendermint/subgraph.js

@@ -0,0 +1,20 @@
+const immutable = require('immutable')
+
+module.exports = class TendermintSubgraph {
+  constructor(options = {}) {
+    this.manifest = options.manifest
+    this.resolveFile = options.resolveFile
+    this.protocol = options.protocol
+  }
+
+  validateManifest() {
+    return immutable.List()
+  }
+
+  handlerTypes() {
+    return immutable.List([
+      'blockHandlers',
+      'eventHandlers',
+    ])
+  }
+}

package/src/scaffold/index.js

@@ -50,7 +50,7 @@ module.exports = class Scaffold {
         },
         dependencies: {
           '@graphprotocol/graph-cli': GRAPH_CLI_VERSION,
-          '@graphprotocol/graph-ts': `0.24.1`,
+          '@graphprotocol/graph-ts': `0.26.0`,
         },
       }),
       { parser: 'json' },

package/src/subgraph.js

@@ -27,7 +27,7 @@ const buildCombinedWarning = (filename, warnings) =>
     ? warnings.reduce(
         (msg, w) =>
           `${msg}
-  
+
     Path: ${w.get('path').size === 0 ? '/' : w.get('path').join(' > ')}
     ${w
       .get('message')
@@ -39,9 +39,21 @@ const buildCombinedWarning = (filename, warnings) =>
 
 module.exports = class Subgraph {
   static async validate(data, protocol, { resolveFile }) {
+    if (protocol.name == null) {
+      return immutable.fromJS([
+        {
+          path: [],
+          message: `Unable to determine for which protocol manifest file is built for. Ensure you have at least one 'dataSources' and/or 'templates' elements defined in your subgraph.`,
+        },
+      ])
+    }
+
     // Parse the default subgraph schema
     let schema = graphql.parse(
-      await fs.readFile(path.join(__dirname, '..', 'manifest-schema.graphql'), 'utf-8'),
+      await fs.readFile(
+        path.join(__dirname, 'protocols', protocol.name, `manifest.graphql`),
+        'utf-8',
+      ),
     )
 
     // Obtain the root `SubgraphManifest` type from the schema
@@ -146,10 +158,7 @@ At least one such handler must be defined.`,
   }
 
   static validateContractValues(manifest, protocol) {
-    return validation.validateContractValues(
-      manifest,
-      protocol,
-    )
+    return validation.validateContractValues(manifest, protocol)
   }
 
   // Validate that data source names are unique, so they don't overwrite each other.
@@ -200,17 +209,13 @@ More than one template named '${name}', template names must be unique.`,
     return yaml.stringify(manifest.toJS())
   }
 
-  static async load(
-    filename,
-    { protocol, skipValidation } = { skipValidation: false }
-  ) {
+  static async load(filename, { protocol, skipValidation } = { skipValidation: false }) {
     // Load and validate the manifest
     let data = null
 
-    if(filename.match(/.js$/)) {
+    if (filename.match(/.js$/)) {
       data = require(path.resolve(filename))
-    }
-    else {
+    } else {
       data = yaml.parse(await fs.readFile(filename, 'utf-8'))
     }
 

package/src/validation/manifest.js

@@ -52,8 +52,7 @@ const validators = immutable.fromJS({
     validators.get(ctx.getIn(['type', 'name', 'value']))(value, ctx),
 
   UnionTypeDefinition: (value, ctx) => {
-    const unionVariants = ctx
-      .getIn(['type', 'types'])
+    const unionVariants = ctx.getIn(['type', 'types'])
 
     let errors = List()
 
@@ -78,7 +77,10 @@ const validators = immutable.fromJS({
 
   NonNullType: (value, ctx) =>
     value !== null && value !== undefined
-      ? validateValue(value, ctx.update('type', type => type.get('type')))
+      ? validateValue(
+          value,
+          ctx.update('type', type => type.get('type')),
+        )
       : immutable.fromJS([
           {
             path: ctx.get('path'),
@@ -126,7 +128,7 @@ const validators = immutable.fromJS({
                     ),
                   )
                 : errors.push(
-                    key == 'templates'
+                    key == 'templates' && ctx.get('protocol').hasTemplates()
                       ? immutable.fromJS({
                           path: ctx.get('path'),
                           message:
@@ -149,6 +151,23 @@ const validators = immutable.fromJS({
         ])
   },
 
+  EnumTypeDefinition: (value, ctx) => {
+    const enumValues = ctx.getIn(['type', 'values']).map((v) => {
+      return v.getIn(['name', 'value'])
+    })
+
+    const allowedValues = enumValues.toArray().join(', ')
+
+    return enumValues.includes(value)
+      ? List()
+      : immutable.fromJS([
+        {
+          path: ctx.get('path'),
+          message: `Unexpected enum value: ${value}, allowed values: ${allowedValues}`,
+        },
+      ])
+  },
+
   String: (value, ctx) =>
     typeof value === 'string'
       ? List()
@@ -211,7 +230,8 @@ const validateValue = (value, ctx) => {
 }
 
 const validateDataSourceForNetwork = (dataSources, protocol) =>
-  dataSources.filter(dataSource => protocol.isValidKindName(dataSource.kind))
+  dataSources
+    .filter(dataSource => protocol.isValidKindName(dataSource.kind))
     .reduce(
       (networks, dataSource) =>
         networks.update(dataSource.network, dataSources =>
@@ -235,11 +255,11 @@ const validateDataSourceNetworks = (value, protocol) => {
 ${networks
   .map(
     (dataSources, network) =>
-    `  ${
+      `  ${
         network === undefined
           ? 'Data sources and templates having no network set'
-        : `Data sources and templates using '${network}'`
-        }:\n${dataSources.map(ds => `    - ${ds}`).join('\n')}`,
+          : `Data sources and templates using '${network}'`
+      }:\n${dataSources.map(ds => `    - ${ds}`).join('\n')}`,
   )
   .join('\n')}
 Recommendation: Make all data sources and templates use the same network name.`,
@@ -262,6 +282,7 @@ const validateManifest = (value, type, schema, protocol, { resolveFile }) => {
             path: [],
             errors: [],
             resolveFile,
+            protocol,
           }),
         )
       : immutable.fromJS([

package/src/validation/schema.js

@@ -76,12 +76,12 @@ const validateEntityDirective = def =>
   def.directives.find(directive => directive.name.value === 'entity')
     ? List()
     : immutable.fromJS([
-        {
-          loc: def.loc,
-          entity: def.name.value,
-          message: `Defined without @entity directive`,
-        },
-      ])
+      {
+        loc: def.loc,
+        entity: def.name.value,
+        message: `Defined without @entity directive`,
+      },
+    ])
 
 const validateEntityID = def => {
   let idField = def.fields.find(field => field.name.value === 'id')
@@ -99,7 +99,9 @@ const validateEntityID = def => {
   if (
     idField.type.kind === 'NonNullType' &&
     idField.type.type.kind === 'NamedType' &&
-    idField.type.type.name.value === 'ID'
+    (idField.type.type.name.value === 'ID' ||
+      idField.type.type.name.value === 'Bytes' ||
+      idField.type.type.name.value === 'String')
   ) {
     return List()
   } else {
@@ -107,7 +109,7 @@ const validateEntityID = def => {
       {
         loc: idField.loc,
         entity: def.name.value,
-        message: `Field 'id': Entity IDs must be of type ID!`,
+        message: `Field 'id': Entity ids must be of type Bytes! or String!`,
       },
     ])
   }
@@ -115,22 +117,22 @@ const validateEntityID = def => {
 
 const validateListFieldType = (def, field) =>
   field.type.kind === 'NonNullType' &&
-  field.type.kind === 'ListType' &&
-  field.type.type.kind !== 'NonNullType'
+    field.type.kind === 'ListType' &&
+    field.type.type.kind !== 'NonNullType'
     ? immutable.fromJS([
-        {
-          loc: field.loc,
-          entity: def.name.value,
-          message: `\
+      {
+        loc: field.loc,
+        entity: def.name.value,
+        message: `\
 Field '${field.name.value}':
 Field has type [${field.type.type.name.value}]! but
 must have type [${field.type.type.name.value}!]!
 
 Reason: Lists with null elements are not supported.`,
-        },
-      ])
+      },
+    ])
     : field.type.kind === 'ListType' && field.type.type.kind !== 'NonNullType'
-    ? immutable.fromJS([
+      ? immutable.fromJS([
         {
           loc: field.loc,
           entity: def.name.value,
@@ -142,7 +144,7 @@ must have type [${field.type.type.name.value}!]
 Reason: Lists with null elements are not supported.`,
         },
       ])
-    : List()
+      : List()
 
 const unwrapType = type => {
   let innerTypeFromList = listType =>
@@ -159,8 +161,8 @@ const unwrapType = type => {
   return type.kind === 'NonNullType'
     ? innerTypeFromNonNull(type)
     : type.kind === 'ListType'
-    ? innerTypeFromList(type)
-    : type
+      ? innerTypeFromList(type)
+      : type
 }
 
 const gatherLocalTypes = defs =>
@@ -206,8 +208,8 @@ const gatherImportedTypes = defs =>
                 type.fields.find(
                   field => field.name.value == 'as' && field.value.kind == 'StringValue',
                 )
-              ? type.fields.find(field => field.name.value == 'as').value.value
-              : undefined,
+                ? type.fields.find(field => field.name.value == 'as').value.value
+                : undefined,
           ),
         ),
     )
@@ -256,16 +258,15 @@ const validateInnerFieldType = (defs, def, field) => {
   return availableTypes.includes(typeName)
     ? List()
     : immutable.fromJS([
-        {
-          loc: field.loc,
-          entity: def.name.value,
-          message: `\
+      {
+        loc: field.loc,
+        entity: def.name.value,
+        message: `\
 Field '${field.name.value}': \
-Unknown type '${typeName}'.${
-            suggestion !== undefined ? ` Did you mean '${suggestion}'?` : ''
+Unknown type '${typeName}'.${suggestion !== undefined ? ` Did you mean '${suggestion}'?` : ''
           }`,
-        },
-      ])
+      },
+    ])
 }
 
 const validateEntityFieldType = (defs, def, field) =>
@@ -277,14 +278,14 @@ const validateEntityFieldType = (defs, def, field) =>
 const validateEntityFieldArguments = (defs, def, field) =>
   field.arguments.length > 0
     ? immutable.fromJS([
-        {
-          loc: field.loc,
-          entity: def.name.value,
-          message: `\
+      {
+        loc: field.loc,
+        entity: def.name.value,
+        message: `\
 Field '${field.name.value}': \
 Field arguments are not supported.`,
-        },
-      ])
+      },
+    ])
     : List()
 
 const entityFieldExists = (entityDef, name) =>
@@ -390,23 +391,23 @@ const validateEntityFields = (defs, def) =>
 const validateNoImportDirective = def =>
   def.directives.find(directive => directive.name.value == 'import')
     ? List([
-        immutable.fromJS({
-          loc: def.name.loc,
-          entity: def.name.value,
-          message: `@import directive only allowed on '${RESERVED_TYPE}' type`,
-        }),
-      ])
+      immutable.fromJS({
+        loc: def.name.loc,
+        entity: def.name.value,
+        message: `@import directive only allowed on '${RESERVED_TYPE}' type`,
+      }),
+    ])
     : List()
 
 const validateNoFulltext = def =>
   def.directives.find(directive => directive.name.value == 'fulltext')
     ? List([
-        immutable.fromJS({
-          loc: def.name.loc,
-          entity: def.name.value,
-          message: `@fulltext directive only allowed on '${RESERVED_TYPE}' type`,
-        }),
-      ])
+      immutable.fromJS({
+        loc: def.name.loc,
+        entity: def.name.value,
+        message: `@fulltext directive only allowed on '${RESERVED_TYPE}' type`,
+      }),
+    ])
     : List()
 
 const validateFulltextFields = (def, directive) => {
@@ -415,13 +416,13 @@ const validateFulltextFields = (def, directive) => {
       ['name', 'language', 'algorithm', 'include'].includes(argument.name.value)
         ? List([])
         : List([
-            immutable.fromJS({
-              loc: directive.name.loc,
-              entity: def.name.value,
-              directive: fulltextDirectiveName(directive),
-              message: `found invalid argument: '${argument.name.value}', @fulltext directives only allow 'name', 'language', 'algorithm', and 'includes' arguments`,
-            }),
-          ]),
+          immutable.fromJS({
+            loc: directive.name.loc,
+            entity: def.name.value,
+            directive: fulltextDirectiveName(directive),
+            message: `found invalid argument: '${argument.name.value}', @fulltext directives only allow 'name', 'language', 'algorithm', and 'includes' arguments`,
+          }),
+        ]),
     )
   }, List([]))
 }
@@ -431,25 +432,25 @@ const validateFulltextName = (def, directive) => {
   return name
     ? validateFulltextArgumentName(def, directive, name)
     : List([
-        immutable.fromJS({
-          loc: directive.name.loc,
-          entity: def.name.value,
-          directive: fulltextDirectiveName(directive),
-          message: `@fulltext argument 'name' must be specified`,
-        }),
-      ])
+      immutable.fromJS({
+        loc: directive.name.loc,
+        entity: def.name.value,
+        directive: fulltextDirectiveName(directive),
+        message: `@fulltext argument 'name' must be specified`,
+      }),
+    ])
 }
 
 const validateFulltextArgumentName = (def, directive, argument) => {
   return argument.value.kind != 'StringValue'
     ? List([
-        immutable.fromJS({
-          loc: directive.name.loc,
-          entity: def.name.value,
-          directive: fulltextDirectiveName(directive),
-          message: `@fulltext argument 'name' must be a string`,
-        }),
-      ])
+      immutable.fromJS({
+        loc: directive.name.loc,
+        entity: def.name.value,
+        directive: fulltextDirectiveName(directive),
+        message: `@fulltext argument 'name' must be a string`,
+      }),
+    ])
     : List([])
 }
 
@@ -463,13 +464,13 @@ const validateFulltextLanguage = (def, directive) => {
   return language
     ? validateFulltextArgumentLanguage(def, directive, language)
     : List([
-        immutable.fromJS({
-          loc: directive.name.loc,
-          entity: def.name.value,
-          directive: fulltextDirectiveName(directive),
-          message: `@fulltext argument 'language' must be specified`,
-        }),
-      ])
+      immutable.fromJS({
+        loc: directive.name.loc,
+        entity: def.name.value,
+        directive: fulltextDirectiveName(directive),
+        message: `@fulltext argument 'language' must be specified`,
+      }),
+    ])
 }
 
 const validateFulltextArgumentLanguage = (def, directive, argument) => {
@@ -521,13 +522,13 @@ const validateFulltextAlgorithm = (def, directive) => {
   return algorithm
     ? validateFulltextArgumentAlgorithm(def, directive, algorithm)
     : List([
-        immutable.fromJS({
-          loc: directive.name.loc,
-          entity: def.name.value,
-          directive: fulltextDirectiveName(directive),
-          message: `@fulltext argument 'algorithm' must be specified`,
-        }),
-      ])
+      immutable.fromJS({
+        loc: directive.name.loc,
+        entity: def.name.value,
+        directive: fulltextDirectiveName(directive),
+        message: `@fulltext argument 'algorithm' must be specified`,
+      }),
+    ])
 }
 
 const validateFulltextArgumentAlgorithm = (def, directive, argument) => {
@@ -740,12 +741,12 @@ const validateImportDirectiveType = (def, directive, type) => {
   return importDirectiveTypeValidators[type.kind]
     ? importDirectiveTypeValidators[type.kind](def, directive, type)
     : List([
-        immutable.fromJS({
-          loc: directive.name.loc,
-          entity: def.name.value,
-          message: `Import must be one of "Name" or { name: "Name", as: "Alias" }`,
-        }),
-      ])
+      immutable.fromJS({
+        loc: directive.name.loc,
+        entity: def.name.value,
+        message: `Import must be one of "Name" or { name: "Name", as: "Alias" }`,
+      }),
+    ])
 }
 
 const validateImportDirectiveArgumentTypes = (def, directive, argument) => {
@@ -815,12 +816,12 @@ const validateImportDirectiveFields = (def, directive) => {
       ['types', 'from'].includes(argument.name.value)
         ? List([])
         : List([
-            immutable.fromJS({
-              loc: directive.name.loc,
-              entity: def.name.value,
-              message: `found invalid argument: '${argument.name.value}', @import directives only allow 'types' and 'from' arguments`,
-            }),
-          ]),
+          immutable.fromJS({
+            loc: directive.name.loc,
+            entity: def.name.value,
+            message: `found invalid argument: '${argument.name.value}', @import directives only allow 'types' and 'from' arguments`,
+          }),
+        ]),
     )
   }, List([]))
 }
@@ -830,12 +831,12 @@ const validateImportDirectiveTypes = (def, directive) => {
   return types
     ? validateImportDirectiveArgumentTypes(def, directive, types)
     : List([
-        immutable.fromJS({
-          loc: directive.name.loc,
-          entity: def.name.value,
-          message: `@import argument 'types' must be specified`,
-        }),
-      ])
+      immutable.fromJS({
+        loc: directive.name.loc,
+        entity: def.name.value,
+        message: `@import argument 'types' must be specified`,
+      }),
+    ])
 }
 
 const validateImportDirectiveFrom = (def, directive) => {
@@ -843,12 +844,12 @@ const validateImportDirectiveFrom = (def, directive) => {
   return from
     ? validateImportDirectiveArgumentFrom(def, directive, from)
     : List([
-        immutable.fromJS({
-          loc: directive.name.loc,
-          entity: def.name.value,
-          message: `@import argument 'from' must be specified`,
-        }),
-      ])
+      immutable.fromJS({
+        loc: directive.name.loc,
+        entity: def.name.value,
+        message: `@import argument 'from' must be specified`,
+      }),
+    ])
 }
 
 const validateImportDirective = (def, directive) =>
@@ -892,12 +893,12 @@ const validateSubgraphSchemaDirectives = def =>
 const validateTypeHasNoFields = def =>
   def.fields.length
     ? List([
-        immutable.fromJS({
-          loc: def.name.loc,
-          entity: def.name.value,
-          message: `${def.name.value} type is not allowed any fields by convention`,
-        }),
-      ])
+      immutable.fromJS({
+        loc: def.name.loc,
+        entity: def.name.value,
+        message: `${def.name.value} type is not allowed any fields by convention`,
+      }),
+    ])
     : List()
 
 const validateAtLeastOneExtensionField = def => List()
@@ -907,12 +908,12 @@ const typeDefinitionValidators = {
     def.name && def.name.value == RESERVED_TYPE
       ? List.of(...validateSubgraphSchemaDirectives(def), ...validateTypeHasNoFields(def))
       : List.of(
-          ...validateEntityDirective(def),
-          ...validateEntityID(def),
-          ...validateEntityFields(defs, def),
-          ...validateNoImportDirective(def),
-          ...validateNoFulltext(def),
-        ),
+        ...validateEntityDirective(def),
+        ...validateEntityID(def),
+        ...validateEntityFields(defs, def),
+        ...validateNoImportDirective(def),
+        ...validateNoFulltext(def),
+      ),
   ObjectTypeExtension: (_defs, def) => validateAtLeastOneExtensionField(def),
 }
 

package/tests/cli/validation/example-values-found.stderr

@@ -1,10 +1,10 @@
 - Load subgraph from subgraph.yaml
 ⚠ Warnings while loading subgraph from subgraph.yaml: Warnings in subgraph.yaml:
-  
+
     Path: repository
     The repository is still set to https://github.com/graphprotocol/example-subgraph.
     Please replace it with a link to your subgraph source code.
-  
+
     Path: description
     The description is still the one from the example subgraph.
     Please update it to tell users more about your subgraph.

package/tests/cli/validation/invalid-manifest/subgraph.yaml

@@ -1,7 +1,8 @@
 schema:
   file: ./non-existent.grapqhl
 dataSources:
-  - name: 5
+  - kind: ethereum/contract
+    name: 5
     abis:
       name: Foo
     mapping: