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

package/src/validation/{schema.js → schema.ts}

@@ -1,6 +1,6 @@
-const fs = require('fs')
-const graphql = require('graphql/language')
-const immutable = require('immutable')
+import fs from 'fs'
+import * as graphql from 'graphql/language'
+import immutable from 'immutable'
 
 const List = immutable.List
 const Set = immutable.Set
@@ -53,12 +53,12 @@ const RESERVED_TYPE = '_Schema_'
  * Returns a GraphQL type suggestion for a given input type.
  * Returns `undefined` if no suggestion is available for the type.
  */
-const typeSuggestion = typeName =>
+export const typeSuggestion = (typeName: string) =>
   TYPE_SUGGESTIONS.filter(([pattern, _]) => {
     return typeof pattern === 'string' ? pattern === typeName : typeName.match(pattern)
   }).map(([_, suggestion]) => suggestion)[0]
 
-const loadSchema = filename => {
+const loadSchema = (filename: string) => {
   try {
     return fs.readFileSync(filename, 'utf-8')
   } catch (e) {
@@ -66,7 +66,7 @@ const loadSchema = filename => {
   }
 }
 
-const parseSchema = doc => {
+const parseSchema = (doc: string) => {
   try {
     return graphql.parse(doc)
   } catch (e) {
@@ -74,19 +74,19 @@ const parseSchema = doc => {
   }
 }
 
-const validateEntityDirective = def =>
-  def.directives.find(directive => directive.name.value === 'entity')
+const validateEntityDirective = (def: any) =>
+  def.directives.find((directive: any) => 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')
+const validateEntityID = (def: any) => {
+  let idField = def.fields.find((field: any) => field.name.value === 'id')
 
   if (idField === undefined) {
     return immutable.fromJS([
@@ -117,24 +117,24 @@ const validateEntityID = def => {
   }
 }
 
-const validateListFieldType = (def, field) =>
+const validateListFieldType = (def: any, field: any) =>
   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,
@@ -146,15 +146,15 @@ must have type [${field.type.type.name.value}!]
 Reason: Lists with null elements are not supported.`,
         },
       ])
-      : List()
+    : List()
 
-const unwrapType = type => {
-  let innerTypeFromList = listType =>
+const unwrapType = (type: any) => {
+  let innerTypeFromList = (listType: any): any =>
     listType.type.kind === 'NonNullType'
       ? innerTypeFromNonNull(listType.type)
       : listType.type
 
-  let innerTypeFromNonNull = nonNullType =>
+  let innerTypeFromNonNull = (nonNullType: any): any =>
     nonNullType.type.kind === 'ListType'
       ? innerTypeFromList(nonNullType.type)
       : nonNullType.type
@@ -163,11 +163,11 @@ const unwrapType = type => {
   return type.kind === 'NonNullType'
     ? innerTypeFromNonNull(type)
     : type.kind === 'ListType'
-      ? innerTypeFromList(type)
-      : type
+    ? innerTypeFromList(type)
+    : type
 }
 
-const gatherLocalTypes = defs =>
+const gatherLocalTypes = (defs: readonly graphql.DefinitionNode[]) =>
   defs
     .filter(
       def =>
@@ -175,50 +175,56 @@ const gatherLocalTypes = defs =>
         def.kind === 'EnumTypeDefinition' ||
         def.kind === 'InterfaceTypeDefinition',
     )
-    .map(def => def.name.value)
+    .map(
+      def =>
+        // @ts-expect-error TODO: name field does not exist on definition, really?
+        def.name.value,
+    )
 
-const gatherImportedTypes = defs =>
+const gatherImportedTypes = (defs: readonly graphql.DefinitionNode[]) =>
   defs
     .filter(
       def =>
         def.kind === 'ObjectTypeDefinition' &&
         def.name.value == RESERVED_TYPE &&
-        def.directives.find(
-          directive =>
+        def.directives?.find(
+          (directive: any) =>
             directive.name.value == 'import' &&
-            directive.arguments.find(argument => argument.name.value == 'types'),
+            directive.arguments.find((argument: any) => argument.name.value == 'types'),
         ),
     )
     .map(def =>
+      // @ts-expect-error TODO: directives field does not exist on definition, really?
       def.directives
         .filter(
-          directive =>
+          (directive: any) =>
             directive.name.value == 'import' &&
-            directive.arguments.find(argument => argument.name.value == 'types'),
+            directive.arguments.find((argument: any) => argument.name.value == 'types'),
         )
-        .map(imp =>
+        .map((imp: any) =>
           imp.arguments.find(
-            argument =>
+            (argument: any) =>
               argument.name.value == 'types' && argument.value.kind == 'ListValue',
           ),
         )
-        .map(arg =>
-          arg.value.values.map(type =>
+        .map((arg: any) =>
+          arg.value.values.map((type: any) =>
             type.kind == 'StringValue'
               ? type.value
               : type.kind == 'ObjectValue' &&
                 type.fields.find(
-                  field => field.name.value == 'as' && field.value.kind == 'StringValue',
+                  (field: any) =>
+                    field.name.value == 'as' && field.value.kind == 'StringValue',
                 )
-                ? type.fields.find(field => field.name.value == 'as').value.value
-                : undefined,
+              ? type.fields.find((field: any) => field.name.value == 'as').value.value
+              : undefined,
           ),
         ),
     )
     .reduce(
       (flattened, types_args) =>
         flattened.concat(
-          types_args.reduce((flattened, types_arg) => {
+          types_args.reduce((flattened: any, types_arg: any[]) => {
             types_arg.forEach(type => (type ? flattened.push(type) : undefined))
             return flattened
           }, []),
@@ -226,21 +232,22 @@ const gatherImportedTypes = defs =>
       [],
     )
 
-const entityTypeByName = (defs, name) =>
+const entityTypeByName = (defs: any[], name: string) =>
   defs
     .filter(
       def =>
         def.kind === 'InterfaceTypeDefinition' ||
-        (def.kind === 'ObjectTypeDefinition' && def.directives.find(directive => directive.name.value === 'entity'))
+        (def.kind === 'ObjectTypeDefinition' &&
+          def.directives.find((directive: any) => directive.name.value === 'entity')),
     )
     .find(def => def.name.value === name)
 
-const fieldTargetEntityName = field => unwrapType(field.type).name.value
+const fieldTargetEntityName = (field: any) => unwrapType(field.type).name.value
 
-const fieldTargetEntity = (defs, field) =>
+const fieldTargetEntity = (defs: any[], field: any) =>
   entityTypeByName(defs, fieldTargetEntityName(field))
 
-const validateInnerFieldType = (defs, def, field) => {
+const validateInnerFieldType = (defs: any[], def: any, field: any) => {
   let innerType = unwrapType(field.type)
 
   // Get the name of the type
@@ -260,40 +267,43 @@ 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) =>
+const validateEntityFieldType = (defs: any[], def: any, field: any) =>
   List.of(
     ...validateListFieldType(def, field),
     ...validateInnerFieldType(defs, def, field),
   )
 
-const validateEntityFieldArguments = (defs, def, field) =>
+const validateEntityFieldArguments = (_defs: any[], def: any, field: any) =>
   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
-
-const validateDerivedFromDirective = (defs, def, field, directive) => {
+const validateDerivedFromDirective = (
+  defs: any[],
+  def: any,
+  field: any,
+  directive: any,
+) => {
   // Validate that there is a `field` argument and nothing else
   if (directive.arguments.length !== 1 || directive.arguments[0].name.value !== 'field') {
     return immutable.fromJS([
@@ -329,7 +339,7 @@ Value of the @derivedFrom 'field' argument must be a string`,
   }
 
   let derivedFromField = targetEntity.fields.find(
-    field => field.name.value === directive.arguments[0].value.value,
+    (field: any) => field.name.value === directive.arguments[0].value.value,
   )
 
   if (derivedFromField === undefined) {
@@ -350,7 +360,11 @@ 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))) {
+  if (
+    !backRefEntity ||
+    (backRefEntity.name.value !== def.name.value &&
+      !def.interfaces.find((intf: any) => intf.name.value === backRefEntity.name.value))
+  ) {
     return immutable.fromJS([
       {
         loc: directive.loc,
@@ -368,21 +382,26 @@ or one of the interface types that '${def.name.value}' implements`,
   return List()
 }
 
-const validateEntityFieldDirective = (defs, def, field, directive) =>
+const validateEntityFieldDirective = (
+  defs: any[],
+  def: any,
+  field: any,
+  directive: any,
+) =>
   directive.name.value === 'derivedFrom'
     ? validateDerivedFromDirective(defs, def, field, directive)
     : List()
 
-const validateEntityFieldDirectives = (defs, def, field) =>
+const validateEntityFieldDirectives = (defs: any[], def: any, field: any) =>
   field.directives.reduce(
-    (errors, directive) =>
+    (errors: any[], directive: any) =>
       errors.concat(validateEntityFieldDirective(defs, def, field, directive)),
     List(),
   )
 
-const validateEntityFields = (defs, def) =>
+const validateEntityFields = (defs: any, def: any) =>
   def.fields.reduce(
-    (errors, field) =>
+    (errors: any[], field: any) =>
       errors
         .concat(validateEntityFieldType(defs, def, field))
         .concat(validateEntityFieldArguments(defs, def, field))
@@ -390,92 +409,94 @@ const validateEntityFields = (defs, def) =>
     List(),
   )
 
-const validateNoImportDirective = def =>
-  def.directives.find(directive => directive.name.value == 'import')
+const validateNoImportDirective = (def: any) =>
+  def.directives.find((directive: any) => 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')
+const validateNoFulltext = (def: any) =>
+  def.directives.find((directive: any) => 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) => {
-  return directive.arguments.reduce((errors, argument) => {
+const validateFulltextFields = (def: any, directive: any) => {
+  return directive.arguments.reduce((errors: any[], argument: any) => {
     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`,
-          }),
-        ]),
+            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')
+const validateFulltextName = (def: any, directive: any) => {
+  let name = directive.arguments.find((argument: any) => 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`,
-      }),
-    ])
+        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) => {
+const validateFulltextArgumentName = (def: any, directive: any, argument: any) => {
   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([])
 }
 
-const fulltextDirectiveName = directive => {
-  let arg = directive.arguments.find(argument => argument.name.value == 'name')
+const fulltextDirectiveName = (directive: any) => {
+  let arg = directive.arguments.find((argument: any) => argument.name.value == 'name')
   return arg ? arg.value.value : 'Other'
 }
 
-const validateFulltextLanguage = (def, directive) => {
-  let language = directive.arguments.find(argument => argument.name.value == 'language')
+const validateFulltextLanguage = (def: any, directive: any) => {
+  let language = directive.arguments.find(
+    (argument: any) => 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`,
-      }),
-    ])
+        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) => {
+const validateFulltextArgumentLanguage = (def: any, directive: any, argument: any) => {
   let languages = [
     'simple',
     'da',
@@ -519,21 +540,23 @@ const validateFulltextArgumentLanguage = (def, directive, argument) => {
   }
 }
 
-const validateFulltextAlgorithm = (def, directive) => {
-  let algorithm = directive.arguments.find(argument => argument.name.value == 'algorithm')
+const validateFulltextAlgorithm = (def: any, directive: any) => {
+  let algorithm = directive.arguments.find(
+    (argument: any) => 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`,
-      }),
-    ])
+        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) => {
+const validateFulltextArgumentAlgorithm = (def: any, directive: any, argument: any) => {
   if (argument.value.kind != 'EnumValue') {
     return List([
       immutable.fromJS({
@@ -557,8 +580,10 @@ const validateFulltextArgumentAlgorithm = (def, directive, argument) => {
   }
 }
 
-const validateFulltextInclude = (def, directive) => {
-  let include = directive.arguments.find(argument => argument.name.value == 'include')
+const validateFulltextInclude = (def: any, directive: any) => {
+  let include = directive.arguments.find(
+    (argument: any) => argument.name.value == 'include',
+  )
   if (include) {
     if (include.value.kind != 'ListValue') {
       return List([
@@ -571,7 +596,7 @@ const validateFulltextInclude = (def, directive) => {
       ])
     }
     return include.value.values.reduce(
-      (errors, type) =>
+      (errors: any, type: any) =>
         errors.concat(validateFulltextArgumentInclude(def, directive, type)),
       List(),
     )
@@ -587,7 +612,7 @@ const validateFulltextInclude = (def, directive) => {
   }
 }
 
-const validateFulltextArgumentInclude = (def, directive, argument) => {
+const validateFulltextArgumentInclude = (def: any, directive: any, argument: any) => {
   if (argument.kind != 'ObjectValue') {
     return List([
       immutable.fromJS({
@@ -609,13 +634,13 @@ const validateFulltextArgumentInclude = (def, directive, argument) => {
     ])
   }
   return argument.fields.reduce(
-    (errors, field) =>
+    (errors: any[], field: any) =>
       errors.concat(validateFulltextArgumentIncludeFields(def, directive, field)),
     List([]),
   )
 }
 
-const validateFulltextArgumentIncludeFields = (def, directive, field) => {
+const validateFulltextArgumentIncludeFields = (def: any, directive: any, field: any) => {
   if (!['entity', 'fields'].includes(field.name.value)) {
     return List([
       immutable.fromJS({
@@ -646,7 +671,7 @@ const validateFulltextArgumentIncludeFields = (def, directive, field) => {
     ])
   } else if (field.name.value == 'fields' && field.value.kind == 'ListValue') {
     return field.value.values.reduce(
-      (errors, field) =>
+      (errors: any[], field: any) =>
         errors.concat(
           validateFulltextArgumentIncludeFieldsObjects(def, directive, field),
         ),
@@ -657,7 +682,11 @@ const validateFulltextArgumentIncludeFields = (def, directive, field) => {
   }
 }
 
-const validateFulltextArgumentIncludeFieldsObjects = (def, directive, argument) => {
+const validateFulltextArgumentIncludeFieldsObjects = (
+  def: any,
+  directive: any,
+  argument: any,
+) => {
   if (argument.kind != 'ObjectValue') {
     return List([
       immutable.fromJS({
@@ -669,7 +698,7 @@ const validateFulltextArgumentIncludeFieldsObjects = (def, directive, argument)
     ])
   } else {
     return argument.fields.reduce(
-      (errors, field) =>
+      (errors: any[], field: any) =>
         errors.concat(
           validateFulltextArgumentIncludeArgumentFieldsObject(def, directive, field),
         ),
@@ -678,7 +707,11 @@ const validateFulltextArgumentIncludeFieldsObjects = (def, directive, argument)
   }
 }
 
-const validateFulltextArgumentIncludeArgumentFieldsObject = (def, directive, field) => {
+const validateFulltextArgumentIncludeArgumentFieldsObject = (
+  def: any,
+  directive: any,
+  field: any,
+) => {
   if (!['name'].includes(field.name.value)) {
     return List([
       immutable.fromJS({
@@ -703,8 +736,8 @@ const validateFulltextArgumentIncludeArgumentFieldsObject = (def, directive, fie
 }
 
 const importDirectiveTypeValidators = {
-  StringValue: (_def, _directive, _type) => List(),
-  ObjectValue: (def, directive, type) => {
+  StringValue: (_def: any, _directive: any, _type: any) => List(),
+  ObjectValue: (def: any, directive: any, type: any) => {
     let errors = List()
     if (type.fields.length != 2) {
       return errors.push(
@@ -715,7 +748,7 @@ const importDirectiveTypeValidators = {
         }),
       )
     }
-    return type.fields.reduce((errors, field) => {
+    return type.fields.reduce((errors: any[], field: any) => {
       if (!['name', 'as'].includes(field.name.value)) {
         return errors.push(
           immutable.fromJS({
@@ -739,19 +772,27 @@ const importDirectiveTypeValidators = {
   },
 }
 
-const validateImportDirectiveType = (def, directive, type) => {
+const validateImportDirectiveType = (
+  def: any,
+  directive: any,
+  type: { kind: keyof typeof importDirectiveTypeValidators },
+) => {
   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) => {
+const validateImportDirectiveArgumentTypes = (
+  def: any,
+  directive: any,
+  argument: any,
+) => {
   if (argument.value.kind != 'ListValue') {
     return List([
       immutable.fromJS({
@@ -763,12 +804,13 @@ const validateImportDirectiveArgumentTypes = (def, directive, argument) => {
   }
 
   return argument.value.values.reduce(
-    (errors, type) => errors.concat(validateImportDirectiveType(def, directive, type)),
+    (errors: any[], type: any) =>
+      errors.concat(validateImportDirectiveType(def, directive, type)),
     List(),
   )
 }
 
-const validateImportDirectiveArgumentFrom = (def, directive, argument) => {
+const validateImportDirectiveArgumentFrom = (def: any, directive: any, argument: any) => {
   if (argument.value.kind != 'ObjectValue') {
     return List([
       immutable.fromJS({
@@ -789,7 +831,7 @@ const validateImportDirectiveArgumentFrom = (def, directive, argument) => {
     ])
   }
 
-  return argument.value.fields.reduce((errors, field) => {
+  return argument.value.fields.reduce((errors: any[], field: any) => {
     if (!['name', 'id'].includes(field.name.value)) {
       return errors.push(
         immutable.fromJS({
@@ -812,56 +854,56 @@ const validateImportDirectiveArgumentFrom = (def, directive, argument) => {
   }, List())
 }
 
-const validateImportDirectiveFields = (def, directive) => {
-  return directive.arguments.reduce((errors, argument) => {
+const validateImportDirectiveFields = (def: any, directive: any) => {
+  return directive.arguments.reduce((errors: any[], argument: any) => {
     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`,
-          }),
-        ]),
+            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')
+const validateImportDirectiveTypes = (def: any, directive: any) => {
+  let types = directive.arguments.find((argument: any) => 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`,
-      }),
-    ])
+        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')
+const validateImportDirectiveFrom = (def: any, directive: any) => {
+  let from = directive.arguments.find((argument: any) => 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`,
-      }),
-    ])
+        immutable.fromJS({
+          loc: directive.name.loc,
+          entity: def.name.value,
+          message: `@import argument 'from' must be specified`,
+        }),
+      ])
 }
 
-const validateImportDirective = (def, directive) =>
+const validateImportDirective = (def: any, directive: any) =>
   List.of(
     ...validateImportDirectiveFields(def, directive),
     ...validateImportDirectiveTypes(def, directive),
     ...validateImportDirectiveFrom(def, directive),
   )
 
-const validateFulltext = (def, directive) =>
+const validateFulltext = (def: any, directive: any) =>
   List.of(
     ...validateFulltextFields(def, directive),
     ...validateFulltextName(def, directive),
@@ -870,7 +912,7 @@ const validateFulltext = (def, directive) =>
     ...validateFulltextInclude(def, directive),
   )
 
-const validateSubgraphSchemaDirective = (def, directive) => {
+const validateSubgraphSchemaDirective = (def: any, directive: any) => {
   if (directive.name.value == 'import') {
     return validateImportDirective(def, directive)
   } else if (directive.name.value == 'fulltext') {
@@ -886,51 +928,58 @@ const validateSubgraphSchemaDirective = (def, directive) => {
   }
 }
 
-const validateSubgraphSchemaDirectives = def =>
+const validateSubgraphSchemaDirectives = (def: any) =>
   def.directives.reduce(
-    (errors, directive) => errors.concat(validateSubgraphSchemaDirective(def, directive)),
+    (errors: any[], directive: any) =>
+      errors.concat(validateSubgraphSchemaDirective(def, directive)),
     List(),
   )
 
-const validateTypeHasNoFields = def =>
+const validateTypeHasNoFields = (def: any) =>
   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()
+const validateAtLeastOneExtensionField = (_def: any) => List()
 
 const typeDefinitionValidators = {
-  ObjectTypeDefinition: (defs, def) =>
+  ObjectTypeDefinition: (defs: any[], def: any) =>
     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),
-      ),
-  ObjectTypeExtension: (_defs, def) => validateAtLeastOneExtensionField(def),
+          ...validateEntityDirective(def),
+          ...validateEntityID(def),
+          ...validateEntityFields(defs, def),
+          ...validateNoImportDirective(def),
+          ...validateNoFulltext(def),
+        ),
+  ObjectTypeExtension: (_defs: any[], def: any) => validateAtLeastOneExtensionField(def),
 }
 
-const validateTypeDefinition = (defs, def) =>
+const validateTypeDefinition = (
+  defs: any,
+  def: { kind: keyof typeof typeDefinitionValidators },
+) =>
   typeDefinitionValidators[def.kind] !== undefined
     ? typeDefinitionValidators[def.kind](defs, def)
     : List()
 
-const validateTypeDefinitions = defs =>
-  defs.reduce((errors, def) => errors.concat(validateTypeDefinition(defs, def)), List())
+const validateTypeDefinitions = (defs: any) =>
+  defs.reduce(
+    (errors: any[], def: any) => errors.concat(validateTypeDefinition(defs, def)),
+    List(),
+  )
 
-const validateNamingCollisionsInTypes = types => {
+const validateNamingCollisionsInTypes = (types: any) => {
   let seen = Set()
   let conflicting = Set()
-  return types.reduce((errors, type) => {
+  return types.reduce((errors: immutable.List<any>, type: any) => {
     if (seen.has(type) && !conflicting.has(type)) {
       errors = errors.push(
         immutable.fromJS({
@@ -947,10 +996,10 @@ const validateNamingCollisionsInTypes = types => {
   }, List())
 }
 
-const validateNamingCollisions = (local, imported) =>
+const validateNamingCollisions = (local: any[], imported: any) =>
   validateNamingCollisionsInTypes(local.concat(imported))
 
-const validateSchema = filename => {
+export const validateSchema = (filename: string) => {
   let doc = loadSchema(filename)
   let schema = parseSchema(doc)
   return List.of(
@@ -961,5 +1010,3 @@ const validateSchema = filename => {
     ),
   )
 }
-
-module.exports = { typeSuggestion, validateSchema }