fix: refactor so that fetching type metadata without an introspection query is possible

BREAKING CHANGE: the following old way of prefetching the metadata is no longer supported:
```js
import getSchemaTypes from 'apollo-magic-refetch/getSchemaTypes'
import client from './wherever/you/create/your/apollo/client'

getSchemaTypes(client)
```

Instead, do the following:
```js
import refetch from 'apollo-magic-refetch'
import client from './wherever/you/create/your/apollo/client'

refetch.fetchTypeMetadata(client)
```

Since it is common to disable introspection queries in production, I have refactored to
support fetching the type metadata by other means.

For instance, you could set up the following route on your server:

```js
import { execute } from 'graphql'
import schema from './path/to/your/graphql/schema'
import express from 'express'
import { typesQuery } from 'apollo-magic-refetch'

const app = express()

const typeMetadataPromise = execute(schema, typesQuery)

app.get('/graphql/refetchTypeMetadata', (req, res) => {
  typeMetadataPromise.then(data => res.json(data))
})
```

And then pass this data to `refetch.setTypeMetadata` **before you ever call
`refetch()`**:

```js
import refetch from 'apollo-magic-refetch'

// accepts a promise that resolves to the graphql execution result.
refetch.setTypeMetadata(
  fetch('/graphql/refetchTypeMetadata').then(res => res.json())
)
```

Author: jedwards1211

README.md

@@ -68,16 +68,45 @@ If you are not using a bundler that supports the `modules.root` property in
 `apollo-magic-refetch` uses type metadata that it must fetch from GraphQL.
 If your schema is large enough it may be a prohibitive amount of metadata.
 `refetch` operations will be delayed until this metadata is fetched.
-To prefetch this metadata, do:
+To prefetch this metadata via a GraphQL introspection query, do:
 
 ```js
 import client from './wherever/you/create/your/apollo/client'
-import getSchemaTypes from 'apollo-magic-refetch/getSchemaTypes'
+import refetch from 'apollo-magic-refetch'
 
 // initiate the prefetch
-getSchemaTypes(client)
+refetch.fetchTypeMetadata(client)
 ```
 
+If your server forbids introspection queries, you will have to fetch it by
+other means. For instance, you could set up the following route on your server:
+
+````js
+import { execute } from 'graphql'
+import schema from './path/to/your/graphql/schema'
+import express from 'express'
+import { typesQuery } from 'apollo-magic-refetch'
+
+const app = express()
+
+const typeMetadataPromise = execute(schema, typesQuery)
+
+app.get('/graphql/refetchTypeMetadata', (req, res) => {
+  typeMetadataPromise.then(data => res.json(data))
+})```
+
+And then pass this data to `refetch.setTypeMetadata` **before you ever call
+`refetch()`**:
+
+```js
+import refetch from 'apollo-magic-refetch'
+
+// accepts a promise that resolves to the graphql execution result.
+refetch.setTypeMetadata(
+  fetch('/graphql/refetchTypeMetadata').then(res => res.json())
+)
+````
+
 ## Handling Deletions
 
 In this example, the `__typename` of the object being deleted is `Device` and it

src/getSchemaTypes.js

@@ -1,7 +1,6 @@
 // @flow
 
-import type { ApolloClient } from 'apollo-client'
-import typesQuery from './typesQuery'
+import type { TypeMetadata } from './typesQuery'
 
 export type RawField = {
   name: string,
@@ -31,8 +30,6 @@ export type Type = {
 
 export type Types = { [name: string]: Type }
 
-let promise: ?Promise<Types>
-
 function convertRawField({ name, type }: RawField): Field {
   return ({ name, type: convertRawType(type) }: any)
 }
@@ -88,18 +85,13 @@ export function linkTypes(rawTypes: Array<RawType>): Types {
   return types
 }
 
-async function getSchemaTypes(client: ApolloClient<any>): Promise<Types> {
+export default async function getSchemaTypes(
+  fetchTypeMetadata: () => Promise<TypeMetadata>
+): Promise<Types> {
   const {
     data: {
       __schema: { types },
     },
-  } = await client.query({ query: typesQuery })
-  return linkTypes(types)
-}
-
-export default function getSchemaTypesOnce(
-  client: ApolloClient<any>
-): Promise<Types> {
-  if (!promise) promise = getSchemaTypes(client)
-  return promise
+  } = await fetchTypeMetadata()
+  return linkTypes((types: any))
 }

src/index.js

@@ -4,7 +4,9 @@ import { ApolloClient } from 'apollo-client'
 import getSchemaTypes from './getSchemaTypes'
 import type { Types } from './getSchemaTypes'
 import doesQueryContain from './doesQueryContain'
-export { default as typesQuery } from './typesQuery'
+import typesQuery, { type TypeMetadata } from './typesQuery'
+export { typesQuery }
+export type { TypeMetadata }
 
 function normalizePredicate(
   predicate: any,
@@ -29,18 +31,20 @@ function every<T>(
   return true
 }
 
+let typesPromise: ?Promise<Types> = null
+
 export default async function refetch(
   client: mixed,
   typenameOrTerms: string | $ReadOnlyArray<Term>,
   predicate?: ?any,
   idField?: string
 ): Promise<any> {
-  if (!(client instanceof ApolloClient))
+  if (!(client instanceof ApolloClient)) {
     throw new Error(
       `client must be an ApolloClient, instead got: ${String(client)}`
     )
-
-  const types: Types = await getSchemaTypes(client)
+  }
+  const types: Types = await refetch.fetchTypeMetadata(client)
 
   let terms
   if (typeof typenameOrTerms === 'string') {
@@ -80,3 +84,18 @@ export default async function refetch(
   }
   await promises
 }
+
+refetch.fetchTypeMetadata = async function(
+  client: ApolloClient<any>
+): Promise<Types> {
+  if (!typesPromise) {
+    refetch.setTypeMetadata(client.query({ query: typesQuery }))
+  }
+  // istanbul ignore next
+  if (!typesPromise) throw new Error('this should never happen')
+  return await typesPromise
+}
+
+refetch.setTypeMetadata = (metadata: Promise<TypeMetadata> | TypeMetadata) => {
+  typesPromise = getSchemaTypes(async () => await metadata)
+}

src/typesQuery.js

@@ -29,3 +29,37 @@ export default gql`
     }
   }
 `
+
+type __TypeKind =
+  | 'SCALAR'
+  | 'OBJECT'
+  | 'INTERFACE'
+  | 'UNION'
+  | 'ENUM'
+  | 'INPUT_OBJECT'
+  | 'LIST'
+  | 'NON_NULL'
+
+export type TypeMetadata = {
+  data: {
+    __schema: {
+      types: Array<{
+        name: ?string,
+        fields: ?Array<{
+          name: string,
+          type: {
+            name: ?string,
+            kind: __TypeKind,
+            ofType: ?{
+              name: ?string,
+              kind: __TypeKind,
+              ofType: ?{
+                name: ?string,
+              },
+            },
+          },
+        }>,
+      }>,
+    },
+  },
+}