feat: import directives (#35)

* Added unittest

* Update testcase

* Remove directive @FIRST on tests

* Workaground for directive import

* Using new type for Definitions

* Clean-up cloned code

* Collect directives on Node

* fix tests coverage

README.md

@@ -41,7 +41,7 @@ Assume the following directory structure:
 
 type A {
   # test 1
-  first: String @first
+  first: String
   second: Float
   b: B
 }
@@ -70,7 +70,7 @@ Running `console.log(importSchema('a.graphql'))` procudes the following output:
 
 ```graphql
 type A {
-  first: String @first
+  first: String
   second: Float
   b: B
 }

docs/index.html

@@ -90,7 +90,7 @@ <h2 id="example">Example</h2>
 
 type A {
   # test 1
-  first: String @first
+  first: String
   second: Float
   b: B
 }
@@ -110,7 +110,7 @@ <h2 id="example">Example</h2>
 </code></pre>
 				<p>Running <code>console.log(importSchema(&#39;a.graphql&#39;))</code> procudes the following output:</p>
 				<pre><code class="lang-graphql">type A {
-  first: String @first
+  first: String
   second: Float
   b: B
 }

fixtures/circular/a.graphql

@@ -1,7 +1,7 @@
 # import * from "b.graphql"
 
 type A {
-  first: String @first
+  first: String
   second: Float
   b: B
 }

fixtures/directive/a.graphql

@@ -0,0 +1,5 @@
+#import * from 'd.graphql'
+type A {
+  first: String @upper
+  second: String @withB @deprecated
+}

fixtures/directive/b.graphql

@@ -0,0 +1 @@
+scalar B

fixtures/directive/d.graphql

@@ -0,0 +1,3 @@
+#import B from 'b.graphql'
+directive @upper on FIELD_DEFINITION
+directive @withB(argB: B) on FIELD_DEFINITION

fixtures/enums/a.graphql

@@ -2,7 +2,7 @@
 
 type A {
   # test 1
-  first: String @first
+  first: String
   second: Float
   b: B
 }

fixtures/field-types/a.graphql

@@ -2,7 +2,7 @@
 
 type A {
   # test 1
-  first: String @first
+  first: String
   second: Float
   b: B
 }

fixtures/import-all/a.graphql

@@ -2,7 +2,7 @@
 
 type A {
   # test 1
-  first: String @first
+  first: String
   second: Float
   b: B
 }

fixtures/input-types/a.graphql

@@ -2,6 +2,6 @@
 
 type A {
   # test 1
-  first(b: B): String @first
+  first(b: B): String
   second: Float
 }

fixtures/interfaces/a.graphql

@@ -2,6 +2,6 @@
 
 type A implements B {
   # test 1
-  first: String @first
+  first: String
   second: Float
 }

fixtures/related-types/a.graphql

@@ -2,7 +2,7 @@
 
 type A {
   # test 1
-  first: String @first
+  first: String
   second: Float
   b: B
 }

fixtures/type-not-found/g.graphql

@@ -0,0 +1,3 @@
+type U {
+  hello: String! @first
+}

src/definition.ts

@@ -6,12 +6,22 @@ import {
   InputObjectTypeDefinitionNode,
   TypeNode,
   NamedTypeNode,
+  DirectiveNode,
+  DirectiveDefinitionNode,
+  InputValueDefinitionNode,
+  FieldDefinitionNode,
 } from 'graphql'
 
 const builtinTypes = ['String', 'Float', 'Int', 'Boolean', 'ID']
 
+const builtinDirectives = ['deprecated', 'skip','include']
+
+export type ValidDefinitionNode =
+    | DirectiveDefinitionNode
+    | TypeDefinitionNode
+
 export interface DefinitionMap {
-  [key: string]: TypeDefinitionNode
+  [key: string]: ValidDefinitionNode
 }
 
 /**
@@ -24,10 +34,10 @@ export interface DefinitionMap {
  * @returns Final collection of type definitions for the resulting schema
  */
 export function completeDefinitionPool(
-  allDefinitions: TypeDefinitionNode[],
-  definitionPool: TypeDefinitionNode[],
-  newTypeDefinitions: TypeDefinitionNode[],
-): TypeDefinitionNode[] {
+  allDefinitions: ValidDefinitionNode[],
+  definitionPool: ValidDefinitionNode[],
+  newTypeDefinitions: ValidDefinitionNode[],
+): ValidDefinitionNode[] {
   const visitedDefinitions: { [name: string]: boolean } = {}
   while (newTypeDefinitions.length > 0) {
     const schemaMap: DefinitionMap = keyBy(allDefinitions, d => d.name.value)
@@ -65,52 +75,24 @@ export function completeDefinitionPool(
  * @returns All relevant type definitions to add to the final schema
  */
 function collectNewTypeDefinitions(
-  allDefinitions: TypeDefinitionNode[],
-  definitionPool: TypeDefinitionNode[],
-  newDefinition: TypeDefinitionNode,
+  allDefinitions: ValidDefinitionNode[],
+  definitionPool: ValidDefinitionNode[],
+  newDefinition: ValidDefinitionNode,
   schemaMap: DefinitionMap,
-): TypeDefinitionNode[] {
-  let newTypeDefinitions: TypeDefinitionNode[] = []
+): ValidDefinitionNode[] {
+  let newTypeDefinitions: ValidDefinitionNode[] = []
 
-  if (newDefinition.kind === 'InputObjectTypeDefinition') {
-    newDefinition.fields.forEach(field => {
-      const namedType = getNamedType(field.type)
-      const typeName = namedType.name.value
+  if (newDefinition.kind !== 'DirectiveDefinition') {
+    newDefinition.directives.forEach(collectDirective)
+  }
 
-      // collect missing argument input types
-      if (
-        !definitionPool.some(d => d.name.value === typeName) &&
-        !builtinTypes.includes(typeName)
-      ) {
-        const argTypeMatch = schemaMap[typeName]
-        if (!argTypeMatch) {
-          throw new Error(
-            `Field ${field.name.value}: Couldn't find type ${typeName} in any of the schemas.`,
-          )
-        }
-        newTypeDefinitions.push(argTypeMatch)
-      }
-    })
+  if (newDefinition.kind === 'InputObjectTypeDefinition') {
+    newDefinition.fields.forEach(collectNode)
   }
 
   if (newDefinition.kind === 'InterfaceTypeDefinition') {
     const interfaceName = newDefinition.name.value
-    newDefinition.fields.forEach(field => {
-      const namedType = getNamedType(field.type)
-      const typeName = namedType.name.value
-      if (
-        !definitionPool.some(d => d.name.value === typeName) &&
-        !builtinTypes.includes(typeName)
-      ) {
-        const schemaType = schemaMap[typeName] as ObjectTypeDefinitionNode
-        if (!schemaType) {
-          throw new Error(
-            `Field ${field.name.value}: Couldn't find type ${typeName} in any of the schemas.`,
-          )
-        }
-        newTypeDefinitions.push(schemaType)
-      }
-    })
+    newDefinition.fields.forEach(collectNode)
 
     const interfaceImplementations = allDefinitions.filter(
       d =>
@@ -150,46 +132,54 @@ function collectNewTypeDefinitions(
 
     // iterate over all fields
     newDefinition.fields.forEach(field => {
-      const namedType = getNamedType(field.type)
-      const typeName = namedType.name.value
-
+      collectNode(field)
       // collect missing argument input types
-      field.arguments.forEach(argument => {
-        const argType = getNamedType(argument.type)
-        const argTypeName = argType.name.value
-        if (
-          !definitionPool.some(d => d.name.value === argTypeName) &&
-          !builtinTypes.includes(argTypeName)
-        ) {
-          const argTypeMatch = schemaMap[argTypeName]
-          if (!argTypeMatch) {
-            throw new Error(
-              `Field ${field.name.value}: Couldn't find type ${
-                argTypeName
-              } in any of the schemas.`,
-            )
-          }
-          newTypeDefinitions.push(argTypeMatch)
-        }
-      })
-
-      // collect missing field types
-      if (
-        !definitionPool.some(d => d.name.value === typeName) &&
-        !builtinTypes.includes(typeName)
-      ) {
-        const schemaType = schemaMap[typeName] as ObjectTypeDefinitionNode
-        if (!schemaType) {
-          throw new Error(
-            `Field ${field.name.value}: Couldn't find type ${typeName} in any of the schemas.`,
-          )
-        }
-        newTypeDefinitions.push(schemaType)
-      }
+      field.arguments.forEach(collectNode)
     })
   }
 
   return newTypeDefinitions
+
+  function collectNode(node: FieldDefinitionNode | InputValueDefinitionNode) {
+    const nodeType = getNamedType(node.type)
+    const nodeTypeName = nodeType.name.value
+
+    // collect missing argument input types
+    if (
+      !definitionPool.some(d => d.name.value === nodeTypeName) &&
+      !builtinTypes.includes(nodeTypeName)
+    ) {
+      const argTypeMatch = schemaMap[nodeTypeName]
+      if (!argTypeMatch) {
+        throw new Error(
+          `Field ${node.name.value}: Couldn't find type ${nodeTypeName} in any of the schemas.`,
+        )
+      }
+      newTypeDefinitions.push(argTypeMatch)
+    }
+
+    node.directives.forEach(collectDirective)
+  }
+
+  function collectDirective(directive: DirectiveNode) {
+    const directiveName = directive.name.value
+    if (
+      !definitionPool.some(d => d.name.value === directiveName) &&
+      !builtinDirectives.includes(directiveName)
+    ) {
+      const directive = schemaMap[directiveName] as DirectiveDefinitionNode
+      if (!directive) {
+        throw new Error(
+          `Directive ${directiveName}: Couldn't find type ${
+            directiveName
+          } in any of the schemas.`,
+        )
+      }
+      directive.arguments.forEach(collectNode)
+
+      newTypeDefinitions.push(directive)
+    }
+  }
 }
 
 /**