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

package/src/validation/schema.js

@@ -1,5 +1,9 @@
 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 = [
@@ -72,26 +76,26 @@ const parseSchema = doc => {
 
 const validateEntityDirective = def =>
   def.directives.find(directive => directive.name.value === 'entity')
-    ? []
-    : [
-        {
-          loc: def.loc,
-          entity: def.name.value,
-          message: `Defined without @entity directive`,
-        },
-      ]
+    ? List()
+    : immutable.fromJS([
+      {
+        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 [
+    return immutable.fromJS([
       {
         loc: def.loc,
         entity: def.name.value,
         message: `Missing field: id: ID!`,
       },
-    ]
+    ])
   }
 
   if (
@@ -101,36 +105,36 @@ const validateEntityID = def => {
       idField.type.type.name.value === 'Bytes' ||
       idField.type.type.name.value === 'String')
   ) {
-    return []
+    return List()
   } else {
-    return [
+    return immutable.fromJS([
       {
         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'
-    ? [
-        {
-          loc: field.loc,
-          entity: def.name.value,
-          message: `\
+    field.type.kind === 'ListType' &&
+    field.type.type.kind !== 'NonNullType'
+    ? immutable.fromJS([
+      {
+        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,
@@ -141,8 +145,8 @@ must have type [${field.type.type.name.value}!]
 
 Reason: Lists with null elements are not supported.`,
         },
-      ]
-    : []
+      ])
+      : List()
 
 const unwrapType = type => {
   let innerTypeFromList = listType =>
@@ -159,8 +163,8 @@ const unwrapType = type => {
   return type.kind === 'NonNullType'
     ? innerTypeFromNonNull(type)
     : type.kind === 'ListType'
-    ? innerTypeFromList(type)
-    : type
+      ? innerTypeFromList(type)
+      : type
 }
 
 const gatherLocalTypes = defs =>
@@ -206,8 +210,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,
           ),
         ),
     )
@@ -227,8 +231,7 @@ 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)
 
@@ -255,18 +258,17 @@ const validateInnerFieldType = (defs, def, field) => {
 
   // Check whether the type name is available, otherwise return an error
   return availableTypes.includes(typeName)
-    ? []
-    : [
-        {
-          loc: field.loc,
-          entity: def.name.value,
-          message: `\
+    ? List()
+    : immutable.fromJS([
+      {
+        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,16 +279,16 @@ const validateEntityFieldType = (defs, def, field) =>
 
 const validateEntityFieldArguments = (defs, def, field) =>
   field.arguments.length > 0
-    ? [
-        {
-          loc: field.loc,
-          entity: def.name.value,
-          message: `\
+    ? immutable.fromJS([
+      {
+        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
@@ -294,7 +296,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 [
+    return immutable.fromJS([
       {
         loc: directive.loc,
         entity: def.name.value,
@@ -302,12 +304,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 [
+    return immutable.fromJS([
       {
         loc: directive.loc,
         entity: def.name.value,
@@ -315,7 +317,7 @@ Field '${field.name.value}': \
 Field '${field.name.value}': \
 Value of the @derivedFrom 'field' argument must be a string`,
       },
-    ]
+    ])
   }
 
   let targetEntity = fieldTargetEntity(defs, field)
@@ -323,7 +325,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 []
+    return immutable.fromJS([])
   }
 
   let derivedFromField = targetEntity.fields.find(
@@ -331,7 +333,7 @@ Value of the @derivedFrom 'field' argument must be a string`,
   )
 
   if (derivedFromField === undefined) {
-    return [
+    return immutable.fromJS([
       {
         loc: directive.loc,
         entity: def.name.value,
@@ -340,7 +342,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)
@@ -348,12 +350,8 @@ 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 [
+  if (!backRefEntity || (backRefEntity.name.value !== def.name.value && !def.interfaces.find(intf => intf.name.value === backRefEntity.name.value))) {
+    return immutable.fromJS([
       {
         loc: directive.loc,
         entity: def.name.value,
@@ -364,22 +362,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 []
+  return List()
 }
 
 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) =>
@@ -389,73 +387,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')
-    ? [
-        {
-          loc: def.name.loc,
-          entity: def.name.value,
-          message: `@import directive only allowed on '${RESERVED_TYPE}' type`,
-        },
-      ]
-    : []
+    ? List([
+      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')
-    ? [
-        {
-          loc: def.name.loc,
-          entity: def.name.value,
-          message: `@fulltext directive only allowed on '${RESERVED_TYPE}' type`,
-        },
-      ]
-    : []
+    ? List([
+      immutable.fromJS({
+        loc: def.name.loc,
+        entity: def.name.value,
+        message: `@fulltext directive only allowed on '${RESERVED_TYPE}' type`,
+      }),
+    ])
+    : List()
 
 const validateFulltextFields = (def, directive) => {
   return directive.arguments.reduce((errors, argument) => {
     return errors.concat(
       ['name', 'language', 'algorithm', 'include'].includes(argument.name.value)
-        ? []
-        : [
-            {
-              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([])
+        : 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`,
+          }),
+        ]),
     )
-  }, [])
+  }, List([]))
 }
 
 const validateFulltextName = (def, directive) => {
   let name = directive.arguments.find(argument => argument.name.value == 'name')
   return name
     ? validateFulltextArgumentName(def, directive, name)
-    : [
-        {
-          loc: directive.name.loc,
-          entity: def.name.value,
-          directive: fulltextDirectiveName(directive),
-          message: `@fulltext argument 'name' must be specified`,
-        },
-      ]
+    : List([
+      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'
-    ? [
-        {
-          loc: directive.name.loc,
-          entity: def.name.value,
-          directive: fulltextDirectiveName(directive),
-          message: `@fulltext argument 'name' must be a string`,
-        },
-      ]
-    : []
+    ? List([
+      immutable.fromJS({
+        loc: directive.name.loc,
+        entity: def.name.value,
+        directive: fulltextDirectiveName(directive),
+        message: `@fulltext argument 'name' must be a string`,
+      }),
+    ])
+    : List([])
 }
 
 const fulltextDirectiveName = directive => {
@@ -467,14 +465,14 @@ const validateFulltextLanguage = (def, directive) => {
   let language = directive.arguments.find(argument => argument.name.value == 'language')
   return language
     ? validateFulltextArgumentLanguage(def, directive, language)
-    : [
-        {
-          loc: directive.name.loc,
-          entity: def.name.value,
-          directive: fulltextDirectiveName(directive),
-          message: `@fulltext argument 'language' must be specified`,
-        },
-      ]
+    : List([
+      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) => {
@@ -497,27 +495,27 @@ const validateFulltextArgumentLanguage = (def, directive, argument) => {
     'tr',
   ]
   if (argument.value.kind != 'EnumValue') {
-    return [
-      {
+    return List([
+      immutable.fromJS({
         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 [
-      {
+    return List([
+      immutable.fromJS({
         loc: directive.name.loc,
         entity: def.name.value,
         directive: fulltextDirectiveName(directive),
         message: `@fulltext directive 'language' value must be one of: ${languages.join(
           ', ',
         )}`,
-      },
-    ]
+      }),
+    ])
   } else {
-    return []
+    return List([])
   }
 }
 
@@ -525,35 +523,35 @@ const validateFulltextAlgorithm = (def, directive) => {
   let algorithm = directive.arguments.find(argument => argument.name.value == 'algorithm')
   return algorithm
     ? validateFulltextArgumentAlgorithm(def, directive, algorithm)
-    : [
-        {
-          loc: directive.name.loc,
-          entity: def.name.value,
-          directive: fulltextDirectiveName(directive),
-          message: `@fulltext argument 'algorithm' must be specified`,
-        },
-      ]
+    : List([
+      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) => {
   if (argument.value.kind != 'EnumValue') {
-    return [
-      {
+    return List([
+      immutable.fromJS({
         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 [
-      {
+    return List([
+      immutable.fromJS({
         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([])
   }
@@ -563,52 +561,52 @@ const validateFulltextInclude = (def, directive) => {
   let include = directive.arguments.find(argument => argument.name.value == 'include')
   if (include) {
     if (include.value.kind != 'ListValue') {
-      return [
-        {
+      return List([
+        immutable.fromJS({
           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 [
-      {
+    return List([
+      immutable.fromJS({
         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 [
-      {
+    return List([
+      immutable.fromJS({
         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 [
-      {
+    return List([
+      immutable.fromJS({
         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) =>
@@ -619,33 +617,33 @@ const validateFulltextArgumentInclude = (def, directive, argument) => {
 
 const validateFulltextArgumentIncludeFields = (def, directive, field) => {
   if (!['entity', 'fields'].includes(field.name.value)) {
-    return [
-      {
+    return List([
+      immutable.fromJS({
         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 [
-      {
+    return List([
+      immutable.fromJS({
         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 [
-      {
+    return List([
+      immutable.fromJS({
         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) =>
@@ -661,74 +659,80 @@ const validateFulltextArgumentIncludeFields = (def, directive, field) => {
 
 const validateFulltextArgumentIncludeFieldsObjects = (def, directive, argument) => {
   if (argument.kind != 'ObjectValue') {
-    return [
-      {
+    return List([
+      immutable.fromJS({
         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 [
-      {
+    return List([
+      immutable.fromJS({
         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 [
-      {
+    return List([
+      immutable.fromJS({
         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) => [],
+  StringValue: (_def, _directive, _type) => List(),
   ObjectValue: (def, directive, type) => {
-    let errors = []
+    let errors = List()
     if (type.fields.length != 2) {
-      return errors.push({
-        loc: directive.name.loc,
-        entity: def.name.value,
-        message: `Import must be one of "Name" or { name: "Name", as: "Alias" }`,
-      })
+      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 type.fields.reduce((errors, field) => {
       if (!['name', 'as'].includes(field.name.value)) {
-        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`,
-        })
+        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`,
+          }),
+        )
       }
       if (field.value.kind != 'StringValue') {
-        return errors.push({
-          loc: directive.name.loc,
-          entity: def.name.value,
-          message: `@import fields [name, as] must be strings`,
-        })
+        return errors.push(
+          immutable.fromJS({
+            loc: directive.name.loc,
+            entity: def.name.value,
+            message: `@import fields [name, as] must be strings`,
+          }),
+        )
       }
       return errors
     }, errors)
@@ -738,112 +742,116 @@ const importDirectiveTypeValidators = {
 const validateImportDirectiveType = (def, directive, type) => {
   return importDirectiveTypeValidators[type.kind]
     ? importDirectiveTypeValidators[type.kind](def, directive, type)
-    : [
-        {
-          loc: directive.name.loc,
-          entity: def.name.value,
-          message: `Import must be one of "Name" or { name: "Name", as: "Alias" }`,
-        },
-      ]
+    : List([
+      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) => {
   if (argument.value.kind != 'ListValue') {
-    return [
-      {
+    return List([
+      immutable.fromJS({
         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 [
-      {
+    return List([
+      immutable.fromJS({
         loc: directive.name.loc,
         entity: def.name.value,
         message: `@import argument 'from' must be an object`,
-      },
-    ]
+      }),
+    ])
   }
 
   if (argument.value.fields.length != 1) {
-    return [
-      {
+    return List([
+      immutable.fromJS({
         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({
-        loc: field.name.loc,
-        entity: def.name.value,
-        message: `@import argument 'from' must be one of { name: "Name" } or { id: "ID" }`,
-      })
+      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" }`,
+        }),
+      )
     }
     if (field.value.kind != 'StringValue') {
-      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.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
-  }, [])
+  }, List())
 }
 
 const validateImportDirectiveFields = (def, directive) => {
   return directive.arguments.reduce((errors, argument) => {
     return errors.concat(
       ['types', 'from'].includes(argument.name.value)
-        ? []
-        : [
-            {
-              loc: directive.name.loc,
-              entity: def.name.value,
-              message: `found invalid argument: '${argument.name.value}', @import directives only allow 'types' and 'from' arguments`,
-            },
-          ],
+        ? 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`,
+          }),
+        ]),
     )
-  }, [])
+  }, List([]))
 }
 
 const validateImportDirectiveTypes = (def, directive) => {
   let types = directive.arguments.find(argument => argument.name.value == 'types')
   return types
     ? validateImportDirectiveArgumentTypes(def, directive, types)
-    : [
-        {
-          loc: directive.name.loc,
-          entity: def.name.value,
-          message: `@import argument 'types' must be specified`,
-        },
-      ]
+    : List([
+      immutable.fromJS({
+        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)
-    : [
-        {
-          loc: directive.name.loc,
-          entity: def.name.value,
-          message: `@import argument 'from' must be specified`,
-        },
-      ]
+    : List([
+      immutable.fromJS({
+        loc: directive.name.loc,
+        entity: def.name.value,
+        message: `@import argument 'from' must be specified`,
+      }),
+    ])
 }
 
 const validateImportDirective = (def, directive) =>
@@ -868,73 +876,75 @@ const validateSubgraphSchemaDirective = (def, directive) => {
   } else if (directive.name.value == 'fulltext') {
     return validateFulltext(def, directive)
   } else {
-    return [
-      {
+    return List([
+      immutable.fromJS({
         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
-    ? [
-        {
-          loc: def.name.loc,
-          entity: def.name.value,
-          message: `${def.name.value} type is not allowed any fields by convention`,
-        },
-      ]
-    : []
+    ? List([
+      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 => []
+const validateAtLeastOneExtensionField = def => List()
 
 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)), [])
+  defs.reduce((errors, def) => errors.concat(validateTypeDefinition(defs, def)), List())
 
 const validateNamingCollisionsInTypes = types => {
   let seen = Set()
   let conflicting = Set()
   return types.reduce((errors, type) => {
     if (seen.has(type) && !conflicting.has(type)) {
-      errors = errors.push({
-        loc: { start: 1, end: 1 },
-        entity: type,
-        message: `Type '${type}' is defined more than once`,
-      })
+      errors = errors.push(
+        immutable.fromJS({
+          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) =>