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

package/src/validation/schema.js

@@ -1,9 +1,5 @@
 const fs = require('fs')
 const graphql = require('graphql/language')
-const immutable = require('immutable')
-
-const List = immutable.List
-const Set = immutable.Set
 
 // Builtin scalar types
 const BUILTIN_SCALAR_TYPES = [
@@ -76,26 +72,26 @@ const parseSchema = doc => {
 
 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')
 
   if (idField === undefined) {
-    return immutable.fromJS([
+    return [
       {
         loc: def.loc,
         entity: def.name.value,
         message: `Missing field: id: ID!`,
       },
-    ])
+    ]
   }
 
   if (
@@ -105,36 +101,36 @@ const validateEntityID = def => {
       idField.type.type.name.value === 'Bytes' ||
       idField.type.type.name.value === 'String')
   ) {
-    return List()
+    return []
   } else {
-    return immutable.fromJS([
+    return [
       {
         loc: idField.loc,
         entity: def.name.value,
         message: `Field 'id': Entity ids must be of type Bytes! or String!`,
       },
-    ])
+    ]
   }
 }
 
 const validateListFieldType = (def, field) =>
   field.type.kind === 'NonNullType' &&
-    field.type.kind === 'ListType' &&
-    field.type.type.kind !== 'NonNullType'
-    ? immutable.fromJS([
-      {
-        loc: field.loc,
-        entity: def.name.value,
-        message: `\
+  field.type.kind === 'ListType' &&
+  field.type.type.kind !== 'NonNullType'
+    ? [
+        {
+          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([
+    ? [
         {
           loc: field.loc,
           entity: def.name.value,
@@ -145,8 +141,8 @@ must have type [${field.type.type.name.value}!]
 
 Reason: Lists with null elements are not supported.`,
         },
-      ])
-      : List()
+      ]
+    : []
 
 const unwrapType = type => {
   let innerTypeFromList = listType =>
@@ -163,8 +159,8 @@ const unwrapType = type => {
   return type.kind === 'NonNullType'
     ? innerTypeFromNonNull(type)
     : type.kind === 'ListType'
-      ? innerTypeFromList(type)
-      : type
+    ? innerTypeFromList(type)
+    : type
 }
 
 const gatherLocalTypes = defs =>
@@ -210,8 +206,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,
           ),
         ),
     )
@@ -231,7 +227,8 @@ const entityTypeByName = (defs, name) =>
     .filter(
       def =>
         def.kind === 'InterfaceTypeDefinition' ||
-        (def.kind === 'ObjectTypeDefinition' && def.directives.find(directive => directive.name.value === 'entity'))
+        (def.kind === 'ObjectTypeDefinition' &&
+          def.directives.find(directive => directive.name.value === 'entity')),
     )
     .find(def => def.name.value === name)
 
@@ -258,17 +255,18 @@ const validateInnerFieldType = (defs, def, field) => {
 
   // Check whether the type name is available, otherwise return an error
   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) =>
@@ -279,16 +277,16 @@ 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) =>
   entityDef.fields.find(field => field.name.value === name) !== undefined
@@ -296,7 +294,7 @@ const entityFieldExists = (entityDef, name) =>
 const validateDerivedFromDirective = (defs, def, field, directive) => {
   // Validate that there is a `field` argument and nothing else
   if (directive.arguments.length !== 1 || directive.arguments[0].name.value !== 'field') {
-    return immutable.fromJS([
+    return [
       {
         loc: directive.loc,
         entity: def.name.value,
@@ -304,12 +302,12 @@ const validateDerivedFromDirective = (defs, def, field, directive) => {
 Field '${field.name.value}': \
 @derivedFrom directive must have a 'field' argument`,
       },
-    ])
+    ]
   }
 
   // Validate that the "field" argument value is a string
   if (directive.arguments[0].value.kind !== 'StringValue') {
-    return immutable.fromJS([
+    return [
       {
         loc: directive.loc,
         entity: def.name.value,
@@ -317,7 +315,7 @@ Field '${field.name.value}': \
 Field '${field.name.value}': \
 Value of the @derivedFrom 'field' argument must be a string`,
       },
-    ])
+    ]
   }
 
   let targetEntity = fieldTargetEntity(defs, field)
@@ -325,7 +323,7 @@ Value of the @derivedFrom 'field' argument must be a string`,
     // This is handled in `validateInnerFieldType` but if we don't catch
     // the undefined case here, the code below will throw, as it assumes
     // the target entity exists
-    return immutable.fromJS([])
+    return []
   }
 
   let derivedFromField = targetEntity.fields.find(
@@ -333,7 +331,7 @@ Value of the @derivedFrom 'field' argument must be a string`,
   )
 
   if (derivedFromField === undefined) {
-    return immutable.fromJS([
+    return [
       {
         loc: directive.loc,
         entity: def.name.value,
@@ -342,7 +340,7 @@ Field '${field.name.value}': \
 @derivedFrom field '${directive.arguments[0].value.value}' \
 does not exist on type '${targetEntity.name.value}'`,
       },
-    ])
+    ]
   }
 
   let backrefTypeName = unwrapType(derivedFromField.type)
@@ -350,8 +348,12 @@ does not exist on type '${targetEntity.name.value}'`,
 
   // The field we are deriving from must either have type 'def' or one of the
   // interface types that 'def' is implementing
-  if (!backRefEntity || (backRefEntity.name.value !== def.name.value && !def.interfaces.find(intf => intf.name.value === backRefEntity.name.value))) {
-    return immutable.fromJS([
+  if (
+    !backRefEntity ||
+    (backRefEntity.name.value !== def.name.value &&
+      !def.interfaces.find(intf => intf.name.value === backRefEntity.name.value))
+  ) {
+    return [
       {
         loc: directive.loc,
         entity: def.name.value,
@@ -362,22 +364,22 @@ on type '${targetEntity.name.value}' must have the type \
 '${def.name.value}', '${def.name.value}!', '[${def.name.value}!]!', \
 or one of the interface types that '${def.name.value}' implements`,
       },
-    ])
+    ]
   }
 
-  return List()
+  return []
 }
 
 const validateEntityFieldDirective = (defs, def, field, directive) =>
   directive.name.value === 'derivedFrom'
     ? validateDerivedFromDirective(defs, def, field, directive)
-    : List()
+    : []
 
 const validateEntityFieldDirectives = (defs, def, field) =>
   field.directives.reduce(
     (errors, directive) =>
       errors.concat(validateEntityFieldDirective(defs, def, field, directive)),
-    List(),
+    [],
   )
 
 const validateEntityFields = (defs, def) =>
@@ -387,73 +389,73 @@ const validateEntityFields = (defs, def) =>
         .concat(validateEntityFieldType(defs, def, field))
         .concat(validateEntityFieldArguments(defs, def, field))
         .concat(validateEntityFieldDirectives(defs, def, field)),
-    List(),
+    [],
   )
 
 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`,
-      }),
-    ])
-    : List()
+    ? [
+        {
+          loc: def.name.loc,
+          entity: def.name.value,
+          message: `@import directive only allowed on '${RESERVED_TYPE}' type`,
+        },
+      ]
+    : []
 
 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`,
-      }),
-    ])
-    : List()
+    ? [
+        {
+          loc: def.name.loc,
+          entity: def.name.value,
+          message: `@fulltext directive only allowed on '${RESERVED_TYPE}' type`,
+        },
+      ]
+    : []
 
 const validateFulltextFields = (def, directive) => {
   return directive.arguments.reduce((errors, argument) => {
     return errors.concat(
       ['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`,
-          }),
-        ]),
+        ? []
+        : [
+            {
+              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([]))
+  }, [])
 }
 
 const validateFulltextName = (def, directive) => {
   let name = directive.arguments.find(argument => argument.name.value == 'name')
   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`,
-      }),
-    ])
+    : [
+        {
+          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`,
-      }),
-    ])
-    : List([])
+    ? [
+        {
+          loc: directive.name.loc,
+          entity: def.name.value,
+          directive: fulltextDirectiveName(directive),
+          message: `@fulltext argument 'name' must be a string`,
+        },
+      ]
+    : []
 }
 
 const fulltextDirectiveName = directive => {
@@ -465,14 +467,14 @@ const validateFulltextLanguage = (def, directive) => {
   let language = directive.arguments.find(argument => argument.name.value == 'language')
   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`,
-      }),
-    ])
+    : [
+        {
+          loc: directive.name.loc,
+          entity: def.name.value,
+          directive: fulltextDirectiveName(directive),
+          message: `@fulltext argument 'language' must be specified`,
+        },
+      ]
 }
 
 const validateFulltextArgumentLanguage = (def, directive, argument) => {
@@ -495,27 +497,27 @@ const validateFulltextArgumentLanguage = (def, directive, argument) => {
     'tr',
   ]
   if (argument.value.kind != 'EnumValue') {
-    return List([
-      immutable.fromJS({
+    return [
+      {
         loc: directive.name.loc,
         entity: def.name.value,
         directive: fulltextDirectiveName(directive),
         message: `@fulltext 'language' value must be one of: ${languages.join(', ')}`,
-      }),
-    ])
+      },
+    ]
   } else if (!languages.includes(argument.value.value)) {
-    return List([
-      immutable.fromJS({
+    return [
+      {
         loc: directive.name.loc,
         entity: def.name.value,
         directive: fulltextDirectiveName(directive),
         message: `@fulltext directive 'language' value must be one of: ${languages.join(
           ', ',
         )}`,
-      }),
-    ])
+      },
+    ]
   } else {
-    return List([])
+    return []
   }
 }
 
@@ -523,35 +525,35 @@ const validateFulltextAlgorithm = (def, directive) => {
   let algorithm = directive.arguments.find(argument => argument.name.value == 'algorithm')
   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`,
-      }),
-    ])
+    : [
+        {
+          loc: directive.name.loc,
+          entity: def.name.value,
+          directive: fulltextDirectiveName(directive),
+          message: `@fulltext argument 'algorithm' must be specified`,
+        },
+      ]
 }
 
 const validateFulltextArgumentAlgorithm = (def, directive, argument) => {
   if (argument.value.kind != 'EnumValue') {
-    return List([
-      immutable.fromJS({
+    return [
+      {
         loc: directive.name.loc,
         entity: def.name.value,
         directive: fulltextDirectiveName(directive),
         message: `@fulltext argument 'algorithm' must be one of: rank, proximityRank`,
-      }),
-    ])
+      },
+    ]
   } else if (!['rank', 'proximityRank'].includes(argument.value.value)) {
-    return List([
-      immutable.fromJS({
+    return [
+      {
         loc: directive.name.loc,
         entity: def.name.value,
         directive: fulltextDirectiveName(directive),
         message: `@fulltext 'algorithm' value, '${argument.value.value}', must be one of: rank, proximityRank`,
-      }),
-    ])
+      },
+    ]
   } else {
     return List([])
   }
@@ -561,52 +563,52 @@ const validateFulltextInclude = (def, directive) => {
   let include = directive.arguments.find(argument => argument.name.value == 'include')
   if (include) {
     if (include.value.kind != 'ListValue') {
-      return List([
-        immutable.fromJS({
+      return [
+        {
           loc: directive.name.loc,
           entity: def.name.value,
           directive: fulltextDirectiveName(directive),
           message: `@fulltext argument 'include' must be a list`,
-        }),
-      ])
+        },
+      ]
     }
     return include.value.values.reduce(
       (errors, type) =>
         errors.concat(validateFulltextArgumentInclude(def, directive, type)),
-      List(),
+      [],
     )
   } else {
-    return List([
-      immutable.fromJS({
+    return [
+      {
         loc: directive.name.loc,
         entity: def.name.value,
         directive: fulltextDirectiveName(directive),
         message: `@fulltext argument 'include' must be specified`,
-      }),
-    ])
+      },
+    ]
   }
 }
 
 const validateFulltextArgumentInclude = (def, directive, argument) => {
   if (argument.kind != 'ObjectValue') {
-    return List([
-      immutable.fromJS({
+    return [
+      {
         loc: directive.name.loc,
         entity: def.name.value,
         directive: fulltextDirectiveName(directive),
         message: `@fulltext argument 'include' must have the form '[{entity: "entityName", fields: [{name: "fieldName"}, ...]} ...]`,
-      }),
-    ])
+      },
+    ]
   }
   if (argument.fields.length != 2) {
-    return List([
-      immutable.fromJS({
+    return [
+      {
         loc: directive.name.loc,
         entity: def.name.value,
         directive: fulltextDirectiveName(directive),
         message: `@fulltext argument include must have two fields, 'entity' and 'fields'`,
-      }),
-    ])
+      },
+    ]
   }
   return argument.fields.reduce(
     (errors, field) =>
@@ -617,33 +619,33 @@ const validateFulltextArgumentInclude = (def, directive, argument) => {
 
 const validateFulltextArgumentIncludeFields = (def, directive, field) => {
   if (!['entity', 'fields'].includes(field.name.value)) {
-    return List([
-      immutable.fromJS({
+    return [
+      {
         loc: directive.name.loc,
         entity: def.name.value,
         directive: fulltextDirectiveName(directive),
         message: `@fulltext argument 'include > ${field.name.value}' must be be one of: entity, fields`,
-      }),
-    ])
+      },
+    ]
   }
   if (field.name.value == 'entity' && field.value.kind != 'StringValue') {
-    return List([
-      immutable.fromJS({
+    return [
+      {
         loc: directive.name.loc,
         entity: def.name.value,
         directive: fulltextDirectiveName(directive),
         message: `@fulltext argument 'include > entity' must be the name of an entity in the schema enclosed in double quotes`,
-      }),
-    ])
+      },
+    ]
   } else if (field.name.value == 'fields' && field.value.kind != 'ListValue') {
-    return List([
-      immutable.fromJS({
+    return [
+      {
         loc: directive.name.loc,
         entity: def.name.value,
         directive: fulltextDirectiveName(directive),
         message: `@fulltext argument 'include > fields' must be a list`,
-      }),
-    ])
+      },
+    ]
   } else if (field.name.value == 'fields' && field.value.kind == 'ListValue') {
     return field.value.values.reduce(
       (errors, field) =>
@@ -659,80 +661,74 @@ const validateFulltextArgumentIncludeFields = (def, directive, field) => {
 
 const validateFulltextArgumentIncludeFieldsObjects = (def, directive, argument) => {
   if (argument.kind != 'ObjectValue') {
-    return List([
-      immutable.fromJS({
+    return [
+      {
         loc: directive.name.loc,
         entity: def.name.value,
         directive: fulltextDirectiveName(directive),
         message: `@fulltext argument 'include > fields' must have the form '[{ name: "fieldName" }, ...]`,
-      }),
-    ])
+      },
+    ]
   } else {
     return argument.fields.reduce(
       (errors, field) =>
         errors.concat(
           validateFulltextArgumentIncludeArgumentFieldsObject(def, directive, field),
         ),
-      List(),
+      [],
     )
   }
 }
 
 const validateFulltextArgumentIncludeArgumentFieldsObject = (def, directive, field) => {
   if (!['name'].includes(field.name.value)) {
-    return List([
-      immutable.fromJS({
+    return [
+      {
         loc: directive.name.loc,
         entity: def.name.value,
         directive: fulltextDirectiveName(directive),
         message: `@fulltext argument 'include > fields' has invalid member '${field.name.value}', must be one of: name`,
-      }),
-    ])
+      },
+    ]
   } else if (field.name.value == 'name' && field.value.kind != 'StringValue') {
-    return List([
-      immutable.fromJS({
+    return [
+      {
         loc: directive.name.loc,
         entity: def.name.value,
         directive: fulltextDirectiveName(directive),
         message: `@fulltext argument 'include > fields > name' must be the name of an entity field enclosed in double quotes`,
-      }),
-    ])
+      },
+    ]
   } else {
     return List([])
   }
 }
 
 const importDirectiveTypeValidators = {
-  StringValue: (_def, _directive, _type) => List(),
+  StringValue: (_def, _directive, _type) => [],
   ObjectValue: (def, directive, type) => {
-    let errors = List()
+    let errors = []
     if (type.fields.length != 2) {
-      return errors.push(
-        immutable.fromJS({
-          loc: directive.name.loc,
-          entity: def.name.value,
-          message: `Import must be one of "Name" or { name: "Name", as: "Alias" }`,
-        }),
-      )
+      return errors.push({
+        loc: directive.name.loc,
+        entity: def.name.value,
+        message: `Import must be one of "Name" or { name: "Name", as: "Alias" }`,
+      })
     }
     return type.fields.reduce((errors, field) => {
       if (!['name', 'as'].includes(field.name.value)) {
-        return errors.push(
-          immutable.fromJS({
-            loc: directive.name.loc,
-            entity: def.name.value,
-            message: `@import field '${field.name.value}' invalid, may only be one of: name, as`,
-          }),
-        )
+        return errors.push({
+          loc: directive.name.loc,
+          entity: def.name.value,
+          message: `@import field '${field.name.value}' invalid, may only be one of: name, as`,
+        })
       }
       if (field.value.kind != 'StringValue') {
-        return errors.push(
-          immutable.fromJS({
-            loc: directive.name.loc,
-            entity: def.name.value,
-            message: `@import fields [name, as] must be strings`,
-          }),
-        )
+        return errors.push({
+          loc: directive.name.loc,
+          entity: def.name.value,
+          message: `@import fields [name, as] must be strings`,
+        })
       }
       return errors
     }, errors)
@@ -742,116 +738,112 @@ const importDirectiveTypeValidators = {
 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" }`,
-      }),
-    ])
+    : [
+        {
+          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) => {
   if (argument.value.kind != 'ListValue') {
-    return List([
-      immutable.fromJS({
+    return [
+      {
         loc: directive.name.loc,
         entity: def.name.value,
         message: `@import argument 'types' must be an list`,
-      }),
-    ])
+      },
+    ]
   }
 
   return argument.value.values.reduce(
     (errors, type) => errors.concat(validateImportDirectiveType(def, directive, type)),
-    List(),
+    [],
   )
 }
 
 const validateImportDirectiveArgumentFrom = (def, directive, argument) => {
   if (argument.value.kind != 'ObjectValue') {
-    return List([
-      immutable.fromJS({
+    return [
+      {
         loc: directive.name.loc,
         entity: def.name.value,
         message: `@import argument 'from' must be an object`,
-      }),
-    ])
+      },
+    ]
   }
 
   if (argument.value.fields.length != 1) {
-    return List([
-      immutable.fromJS({
+    return [
+      {
         loc: directive.name.loc,
         entity: def.name.value,
         message: `@import argument 'from' must have an 'id' or 'name' field`,
-      }),
-    ])
+      },
+    ]
   }
 
   return argument.value.fields.reduce((errors, field) => {
     if (!['name', 'id'].includes(field.name.value)) {
-      return errors.push(
-        immutable.fromJS({
-          loc: field.name.loc,
-          entity: def.name.value,
-          message: `@import argument 'from' must be one of { name: "Name" } or { id: "ID" }`,
-        }),
-      )
+      return errors.push({
+        loc: field.name.loc,
+        entity: def.name.value,
+        message: `@import argument 'from' must be one of { name: "Name" } or { id: "ID" }`,
+      })
     }
     if (field.value.kind != 'StringValue') {
-      return errors.push(
-        immutable.fromJS({
-          loc: field.name.loc,
-          entity: def.name.value,
-          message: `@import argument 'from' must be one of { name: "Name" } or { id: "ID" } with string values`,
-        }),
-      )
+      return errors.push({
+        loc: field.name.loc,
+        entity: def.name.value,
+        message: `@import argument 'from' must be one of { name: "Name" } or { id: "ID" } with string values`,
+      })
     }
     return errors
-  }, List())
+  }, [])
 }
 
 const validateImportDirectiveFields = (def, directive) => {
   return directive.arguments.reduce((errors, argument) => {
     return errors.concat(
       ['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`,
-          }),
-        ]),
+        ? []
+        : [
+            {
+              loc: directive.name.loc,
+              entity: def.name.value,
+              message: `found invalid argument: '${argument.name.value}', @import directives only allow 'types' and 'from' arguments`,
+            },
+          ],
     )
-  }, List([]))
+  }, [])
 }
 
 const validateImportDirectiveTypes = (def, directive) => {
   let types = directive.arguments.find(argument => argument.name.value == 'types')
   return types
     ? validateImportDirectiveArgumentTypes(def, directive, types)
-    : List([
-      immutable.fromJS({
-        loc: directive.name.loc,
-        entity: def.name.value,
-        message: `@import argument 'types' must be specified`,
-      }),
-    ])
+    : [
+        {
+          loc: directive.name.loc,
+          entity: def.name.value,
+          message: `@import argument 'types' must be specified`,
+        },
+      ]
 }
 
 const validateImportDirectiveFrom = (def, directive) => {
   let from = directive.arguments.find(argument => argument.name.value == 'from')
   return from
     ? validateImportDirectiveArgumentFrom(def, directive, from)
-    : List([
-      immutable.fromJS({
-        loc: directive.name.loc,
-        entity: def.name.value,
-        message: `@import argument 'from' must be specified`,
-      }),
-    ])
+    : [
+        {
+          loc: directive.name.loc,
+          entity: def.name.value,
+          message: `@import argument 'from' must be specified`,
+        },
+      ]
 }
 
 const validateImportDirective = (def, directive) =>
@@ -876,75 +868,73 @@ const validateSubgraphSchemaDirective = (def, directive) => {
   } else if (directive.name.value == 'fulltext') {
     return validateFulltext(def, directive)
   } else {
-    return List([
-      immutable.fromJS({
+    return [
+      {
         loc: directive.name.loc,
         entity: def.name.value,
         message: `${RESERVED_TYPE} type only allows @import and @fulltext directives`,
-      }),
-    ])
+      },
+    ]
   }
 }
 
 const validateSubgraphSchemaDirectives = def =>
   def.directives.reduce(
     (errors, directive) => errors.concat(validateSubgraphSchemaDirective(def, directive)),
-    List(),
+    [],
   )
 
 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`,
-      }),
-    ])
-    : List()
+    ? [
+        {
+          loc: def.name.loc,
+          entity: def.name.value,
+          message: `${def.name.value} type is not allowed any fields by convention`,
+        },
+      ]
+    : []
 
-const validateAtLeastOneExtensionField = def => List()
+const validateAtLeastOneExtensionField = def => []
 
 const typeDefinitionValidators = {
   ObjectTypeDefinition: (defs, def) =>
     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),
 }
 
 const validateTypeDefinition = (defs, def) =>
   typeDefinitionValidators[def.kind] !== undefined
     ? typeDefinitionValidators[def.kind](defs, def)
-    : List()
+    : []
 
 const validateTypeDefinitions = defs =>
-  defs.reduce((errors, def) => errors.concat(validateTypeDefinition(defs, def)), List())
+  defs.reduce((errors, def) => errors.concat(validateTypeDefinition(defs, def)), [])
 
 const validateNamingCollisionsInTypes = types => {
   let seen = Set()
   let conflicting = Set()
   return types.reduce((errors, type) => {
     if (seen.has(type) && !conflicting.has(type)) {
-      errors = errors.push(
-        immutable.fromJS({
-          loc: { start: 1, end: 1 },
-          entity: type,
-          message: `Type '${type}' is defined more than once`,
-        }),
-      )
+      errors = errors.push({
+        loc: { start: 1, end: 1 },
+        entity: type,
+        message: `Type '${type}' is defined more than once`,
+      })
       conflicting = conflicting.add(type)
     } else {
       seen = seen.add(type)
     }
     return errors
-  }, List())
+  }, [])
 }
 
 const validateNamingCollisions = (local, imported) =>