@graphprotocol/graph-cli 0.37.2-alpha-20221219142030-0cf2a37 → 0.37.2

package/src/type-generator.js

@@ -1,4 +1,5 @@
 const fs = require('fs-extra')
+const immutable = require('immutable')
 const path = require('path')
 const prettier = require('prettier')
 const graphql = require('graphql/language')
@@ -119,14 +120,14 @@ module.exports = class TypeGenerator {
   }
 
   async loadSchema(subgraph) {
-    let maybeRelativePath = subgraph.schema?.file
+    let maybeRelativePath = subgraph.getIn(['schema', 'file'])
     let absolutePath = path.resolve(this.sourceDir, maybeRelativePath)
     return await withSpinner(
       `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.schema?.file
+        let maybeRelativePath = subgraph.getIn(['schema', 'file'])
         let absolutePath = path.resolve(this.sourceDir, maybeRelativePath)
         return Schema.load(absolutePath)
       },
@@ -168,7 +169,7 @@ module.exports = class TypeGenerator {
       async spinner => {
         // Combine the generated code for all templates
         let codeSegments = subgraph
-          .get('templates', [])
+          .get('templates', immutable.List())
           .reduce((codeSegments, template) => {
             step(
               spinner,
@@ -188,7 +189,7 @@ module.exports = class TypeGenerator {
             }
 
             return codeSegments.concat(codeGenerator.generateTypes())
-          }, [])
+          }, immutable.List())
 
         if (!codeSegments.isEmpty()) {
           let code = prettier.format([GENERATED_FILE_NOTE, ...codeSegments].join('\n'), {
@@ -213,11 +214,11 @@ module.exports = class TypeGenerator {
       files.push(this.options.subgraphManifest)
 
       // Add the GraphQL schema to the watched files
-      files.push(subgraph.schema?.file)
+      files.push(subgraph.getIn(['schema', 'file']))
 
       // Add all file paths specified in manifest
       subgraph.get('dataSources').map(dataSource => {
-        dataSource.mapping?.abis.map(abi => {
+        dataSource.getIn(['mapping', 'abis']).map(abi => {
           files.push(abi.get('file'))
         })
       })

package/src/validation/contract.js

@@ -1,3 +1,5 @@
+const immutable = require('immutable')
+
 const validateContract = (value, ProtocolContract) => {
   const contract = new ProtocolContract(value)
 
@@ -29,7 +31,8 @@ const validateContractValues = (manifest, protocol) => {
         return errors
       }
 
-      let contractValue = dataSource.source[fieldName]
+      let contractValue = dataSource.getIn(['source', fieldName])
+
 
       const { valid, error } = validateContract(contractValue, ProtocolContract)
 
@@ -37,12 +40,14 @@ const validateContractValues = (manifest, protocol) => {
       if (valid) {
         return errors
       } else {
-        return errors.push({
-          path,
-          message: error,
-        })
+        return errors.push(
+          immutable.fromJS({
+            path,
+            message: error,
+          }),
+        )
       }
-    }, [])
+    }, immutable.List())
 }
 
 module.exports = {

package/src/validation/manifest.js

@@ -1,16 +1,20 @@
+const immutable = require('immutable')
 const yaml = require('js-yaml')
 const path = require('path')
 
 const Protocol = require('../protocols')
 
+const List = immutable.List
+const Map = immutable.Map
+
 /**
  * Returns a user-friendly type name for a value.
  */
 const typeName = value =>
-  Array.isArray(value) ? 'list' : typeof value === 'object' ? 'map' : typeof value
+  List.isList(value) ? 'list' : Map.isMap(value) ? 'map' : typeof value
 
 /**
- * Converts a plain JavaScript value to a YAML string.
+ * Converts an immutable or plain JavaScript value to a YAML string.
  */
 const toYAML = x =>
   yaml
@@ -23,7 +27,9 @@ const toYAML = x =>
  * Looks up the type of a field in a GraphQL object type.
  */
 const getFieldType = (type, fieldName) => {
-  let fieldDef = type.get('fields').find(field => field.name?.value === fieldName)
+  let fieldDef = type
+    .get('fields')
+    .find(field => field.getIn(['name', 'value']) === fieldName)
 
   return fieldDef !== undefined ? fieldDef.get('type') : undefined
 }
@@ -35,17 +41,20 @@ const resolveType = (schema, type) =>
   type.has('type')
     ? resolveType(schema, type.get('type'))
     : type.get('kind') === 'NamedType'
-    ? schema.get('definitions').find(def => def.name?.value === type.name?.value)
+    ? schema
+        .get('definitions')
+        .find(def => def.getIn(['name', 'value']) === type.getIn(['name', 'value']))
     : 'resolveType: unimplemented'
 
 /**
  * A map of supported validators.
  */
-const validators = Object.freeze({
-  ScalarTypeDefinition: (value, ctx) => validators.get(ctx.type?.name?.value)(value, ctx),
+const validators = immutable.fromJS({
+  ScalarTypeDefinition: (value, ctx) =>
+    validators.get(ctx.getIn(['type', 'name', 'value']))(value, ctx),
 
   UnionTypeDefinition: (value, ctx) => {
-    const unionVariants = ctx.type?.types
+    const unionVariants = ctx.getIn(['type', 'types'])
 
     let errors = List()
 
@@ -74,12 +83,12 @@ const validators = Object.freeze({
           value,
           ctx.update('type', type => type.get('type')),
         )
-      : [
+      : immutable.fromJS([
           {
             path: ctx.get('path'),
             message: `No value provided`,
           },
-        ],
+        ]),
 
   ListType: (value, ctx) =>
     List.isList(value)
@@ -95,17 +104,18 @@ const validators = Object.freeze({
             ),
           List(),
         )
-      : [
+      : immutable.fromJS([
           {
             path: ctx.get('path'),
             message: `Expected list, found ${typeName(value)}:\n${toYAML(value)}`,
           },
-        ],
+        ]),
 
   ObjectTypeDefinition: (value, ctx) => {
     return Map.isMap(value)
-      ? ctx.type?.fields
-          .map(fieldDef => fieldDef.name?.value)
+      ? ctx
+          .getIn(['type', 'fields'])
+          .map(fieldDef => fieldDef.getIn(['name', 'value']))
           .concat(value.keySeq())
           .toSet()
           .reduce(
@@ -121,97 +131,97 @@ const validators = Object.freeze({
                   )
                 : errors.push(
                     key == 'templates' && ctx.get('protocol').hasTemplates()
-                      ? {
+                      ? immutable.fromJS({
                           path: ctx.get('path'),
                           message:
                             `The way to declare data source templates has changed, ` +
                             `please move the templates from inside data sources to ` +
                             `a \`templates:\` field at the top level of the manifest.`,
-                        }
-                      : {
+                        })
+                      : immutable.fromJS({
                           path: ctx.get('path'),
                           message: `Unexpected key in map: ${key}`,
-                        },
+                        }),
                   ),
             List(),
           )
-      : [
+      : immutable.fromJS([
           {
             path: ctx.get('path'),
             message: `Expected map, found ${typeName(value)}:\n${toYAML(value)}`,
           },
-        ]
+        ])
   },
 
   EnumTypeDefinition: (value, ctx) => {
-    const enumValues = ctx.type?.values.map(v => {
-      return v.name?.value
+    const enumValues = ctx.getIn(['type', 'values']).map((v) => {
+      return v.getIn(['name', 'value'])
     })
 
     const allowedValues = enumValues.toArray().join(', ')
 
     return enumValues.includes(value)
-      ? []
-      : [
-          {
-            path: ctx.get('path'),
-            message: `Unexpected enum value: ${value}, allowed values: ${allowedValues}`,
-          },
-        ]
+      ? List()
+      : immutable.fromJS([
+        {
+          path: ctx.get('path'),
+          message: `Unexpected enum value: ${value}, allowed values: ${allowedValues}`,
+        },
+      ])
   },
 
   String: (value, ctx) =>
     typeof value === 'string'
       ? List()
-      : [
+      : immutable.fromJS([
           {
             path: ctx.get('path'),
             message: `Expected string, found ${typeName(value)}:\n${toYAML(value)}`,
           },
-        ],
+        ]),
 
   BigInt: (value, ctx) =>
     typeof value === 'number'
-      ? []
-      : [
+      ? List()
+      : immutable.fromJS([
           {
             path: ctx.get('path'),
             message: `Expected BigInt, found ${typeName(value)}:\n${toYAML(value)}`,
           },
-        ],
+        ]),
 
   File: (value, ctx) =>
     typeof value === 'string'
       ? require('fs').existsSync(ctx.get('resolveFile')(value))
-        ? []
-        : [
+        ? List()
+        : immutable.fromJS([
             {
               path: ctx.get('path'),
               message: `File does not exist: ${path.relative(process.cwd(), value)}`,
             },
-          ]
-      : [
+          ])
+      : immutable.fromJS([
           {
             path: ctx.get('path'),
             message: `Expected filename, found ${typeName(value)}:\n${value}`,
           },
-        ],
+        ]),
 
   Boolean: (value, ctx) =>
     typeof value === 'boolean'
-      ? []
-      : [
+      ? List()
+      : immutable.fromJS([
           {
             path: ctx.get('path'),
             message: `Expected true or false, found ${typeName(value)}:\n${toYAML(
               value,
             )}`,
           },
-        ],
+        ]),
 })
 
 const validateValue = (value, ctx) => {
-  let kind = ctx.type?.kind
+  let kind = ctx.getIn(['type', 'kind'])
   let validator = validators.get(kind)
 
   if (validator !== undefined) {
@@ -219,17 +229,17 @@ const validateValue = (value, ctx) => {
     // type is wrapped in a `NonNullType`, the validator for that `NonNullType`
     // will catch the missing/unset value
     if (kind !== 'NonNullType' && (value === undefined || value === null)) {
-      return []
+      return List()
     } else {
       return validator(value, ctx)
     }
   } else {
-    return [
+    return immutable.fromJS([
       {
         path: ctx.get('path'),
         message: `No validator for unsupported schema type: ${kind}`,
       },
-    ]
+    ])
   }
 }
 
@@ -241,7 +251,7 @@ const validateValue = (value, ctx) => {
 //   { name: 'contract3', kind: 'near', network: 'near-mainnet' },
 // ]
 //
-// Into JS structure like this (protocol kind is normalized):
+// Into Immutable JS structure like this (protocol kind is normalized):
 // {
 //   ethereum: {
 //     mainnet: ['contract0', 'contract1'],
@@ -252,17 +262,15 @@ const validateValue = (value, ctx) => {
 //   },
 // }
 const dataSourceListToMap = dataSources =>
-  dataSources.reduce((protocolKinds, dataSource) => {
-    const dataSourceName = Protocol.normalizeName(dataSource.kind)
-    if (!protocolKinds[dataSourceName]) {
-      protocolKinds[dataSourceName] = {}
-    }
-    if (!protocolKinds[dataSourceName][dataSource.network]) {
-      protocolKinds[dataSourceName][dataSource.network] = []
-    }
-    protocolKinds[dataSourceName][dataSource.network].push(dataSource.name)
-    return protocolKinds
-  }, {})
+  dataSources
+    .reduce(
+      (protocolKinds, dataSource) =>
+        protocolKinds.update(Protocol.normalizeName(dataSource.kind), networks =>
+          (networks || immutable.OrderedMap()).update(dataSource.network, dataSourceNames =>
+            (dataSourceNames || immutable.OrderedSet()).add(dataSource.name)),
+        ),
+      immutable.OrderedMap(),
+    )
 
 const validateDataSourceProtocolAndNetworks = value => {
   const dataSources = [...value.dataSources, ...(value.templates || [])]
@@ -270,7 +278,7 @@ const validateDataSourceProtocolAndNetworks = value => {
   const protocolNetworkMap = dataSourceListToMap(dataSources)
 
   if (protocolNetworkMap.size > 1) {
-    return [
+    return immutable.fromJS([
       {
         path: [],
         message: `Conflicting protocol kinds used in data sources and templates:
@@ -281,22 +289,18 @@ ${protocolNetworkMap
         protocolKind === undefined
           ? 'Data sources and templates having no protocol kind set'
           : `Data sources and templates using '${protocolKind}'`
-      }:\n${dataSourceNames
-        .valueSeq()
-        .flatten()
-        .map(ds => `    - ${ds}`)
-        .join('\n')}`,
+      }:\n${dataSourceNames.valueSeq().flatten().map(ds => `    - ${ds}`).join('\n')}`,
   )
   .join('\n')}
 Recommendation: Make all data sources and templates use the same protocol kind.`,
       },
-    ]
+    ])
   }
 
   const networks = protocolNetworkMap.first()
 
   if (networks.size > 1) {
-    return [
+    return immutable.fromJS([
       {
         path: [],
         message: `Conflicting networks used in data sources and templates:
@@ -312,30 +316,33 @@ ${networks
   .join('\n')}
 Recommendation: Make all data sources and templates use the same network name.`,
       },
-    ]
+    ])
   }
 
-  return []
+  return List()
 }
 
 const validateManifest = (value, type, schema, protocol, { resolveFile }) => {
   // Validate manifest using the GraphQL schema that defines its structure
   let errors =
     value !== null && value !== undefined
-      ? validateValue(value, {
-          schema: schema,
-          type: type,
-          path: [],
-          errors: [],
-          resolveFile,
-          protocol,
-        })
-      : [
+      ? validateValue(
+          immutable.fromJS(value),
+          immutable.fromJS({
+            schema: schema,
+            type: type,
+            path: [],
+            errors: [],
+            resolveFile,
+            protocol,
+          }),
+        )
+      : immutable.fromJS([
           {
             path: [],
             message: `Expected non-empty value, found ${typeName(value)}:\n  ${value}`,
           },
-        ]
+        ])
 
   // Fail early because a broken manifest prevents us from performing
   // additional validation steps