feat: validate GraphQL documents

Author: jedwards1211

README.md

@@ -469,6 +469,20 @@ Configure this in your `package.json`:
   }
 ```
 
+## `validate` (default: `true`)
+
+Whether to validate each GraphQL document before processing it.
+Excludes `NoUnusedFragmentsRule` from validation, in case you put fragment definitions
+in separate template literals.
+
+Right now this is only configurable in your `package.json`:
+
+```
+  "graphql-typegen": {
+    "validate": false
+  }
+```
+
 ## `addTypename` (default: `true`)
 
 Places this may be configured, in order of increasing precendence:

package.json

@@ -85,7 +85,6 @@
   "devDependencies": {
     "@babel/cli": "^7.1.5",
     "@babel/core": "^7.1.6",
-    "@babel/node": "^7.8.4",
     "@babel/plugin-proposal-class-properties": "^7.1.0",
     "@babel/plugin-proposal-export-default-from": "^7.0.0",
     "@babel/plugin-proposal-export-namespace-from": "^7.0.0",
@@ -136,9 +135,8 @@
   },
   "dependencies": {
     "@babel/runtime": "^7.1.5",
-    "flatted": "^2.0.1",
     "fs-extra": "^8.1.0",
-    "graphql": "^14.5.8",
+    "graphql": "^14.6.0",
     "graphql-tag": "^2.10.1",
     "jscodeshift-add-imports": "^1.0.3",
     "jscodeshift-choose-parser": "^1.0.0",

src/graphql-typegen-async.ts

@@ -23,6 +23,12 @@ module.exports = async function graphqlTypegenAsync(
   }
   const config = applyConfigDefaults(Object.assign(packageConf, options))
   const { schemaFile, server } = config
-  const schema = await analyzeSchema({ schemaFile, server })
-  return graphqlTypegenCore(fileInfo, api, options, { schema })
+  const { analyzed, schema } = await analyzeSchema({
+    schemaFile,
+    server,
+  })
+  return graphqlTypegenCore(fileInfo, api, options, {
+    analyzedSchema: analyzed,
+    schema,
+  })
 }

src/graphql-typegen.ts

@@ -23,6 +23,12 @@ module.exports = function graphqlTypegen(
   }
   const config = applyConfigDefaults(Object.assign(packageConf, options))
   const { schemaFile, server } = config
-  const schema = analyzeSchemaSync({ schemaFile, server })
-  return graphqlTypegenCore(fileInfo, api, options, { schema })
+  const { analyzed, schema } = analyzeSchemaSync({
+    schemaFile,
+    server,
+  })
+  return graphqlTypegenCore(fileInfo, api, options, {
+    analyzedSchema: analyzed,
+    schema,
+  })
 }

src/internal/analyzeSchema.ts

@@ -1,95 +1,13 @@
 #! /usr/bin/env babel-node --extensions .js,.ts
 /* eslint-disable @typescript-eslint/no-use-before-define */
 
-import gql from 'graphql-tag'
 import * as graphql from 'graphql'
 import superagent from 'superagent'
 import getConfigDirectives, { ConfigDirectives } from './getConfigDirectives'
 import { execFileSync } from 'child_process'
+import { getIntrospectionQuery } from 'graphql/utilities/introspectionQuery'
 import * as fs from 'fs'
 import * as path from 'path'
-import flatted from 'flatted'
-
-const typesQuery = gql`
-  fragment typeInfo on __Type {
-    name
-    kind
-    # Fetch really deep just in case someone is doing something like [[[Float!]!]!]!...
-    # Haven't devised a plan to deal with arbitrarily deep types yet
-    ofType {
-      name
-      kind
-      ofType {
-        name
-        kind
-        ofType {
-          name
-          kind
-          ofType {
-            name
-            kind
-            ofType {
-              name
-              kind
-              ofType {
-                name
-                kind
-                ofType {
-                  name
-                  kind
-                  ofType {
-                    name
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  query getTypes {
-    __schema {
-      types {
-        kind
-        name
-        description
-        enumValues {
-          name
-          description
-        }
-        interfaces {
-          name
-          description
-        }
-        possibleTypes {
-          ...typeInfo
-        }
-        fields {
-          name
-          description
-          args {
-            name
-            description
-            type {
-              ...typeInfo
-            }
-          }
-          type {
-            ...typeInfo
-          }
-        }
-        inputFields {
-          name
-          description
-          type {
-            ...typeInfo
-          }
-        }
-      }
-    }
-  }
-`
 
 export type TypeKind =
   | 'SCALAR'
@@ -176,13 +94,14 @@ export type AnalyzedType = {
 }
 
 function analyzeTypes(
-  introspectionTypes: Array<IntrospectionType>,
+  data: graphql.IntrospectionQuery,
   {
     cwd,
   }: {
     cwd: string
   }
 ): Record<string, AnalyzedType> {
+  const introspectionTypes: IntrospectionType[] = data.__schema.types as any
   function getDescriptionDirectives(
     description: string | undefined
   ): ConfigDirectives {
@@ -340,55 +259,73 @@ function analyzeTypes(
 }
 
 export type AnalyzedSchema = Record<string, AnalyzedType>
+export type AnalyzeResult = {
+  analyzed: AnalyzedSchema
+  schema: graphql.GraphQLSchema
+}
 
-export default async function analyzeSchema({
+export async function getIntrospectionData({
   schema,
   schemaFile,
   server,
 }: {
   schemaFile?: string
   schema?: graphql.GraphQLSchema
   server?: string
-}): Promise<AnalyzedSchema> {
-  let result: graphql.ExecutionResult<{
-    __schema: { types: IntrospectionType[] }
-  }>
+}): Promise<graphql.IntrospectionQuery> {
   if (schemaFile)
     schema = graphql.buildSchema(fs.readFileSync(schemaFile, 'utf8'))
-  if (schema) result = await graphql.execute(schema, typesQuery)
+  const introspectionQuery = graphql.parse(getIntrospectionQuery())
+  let introspection
+  if (schema) introspection = await graphql.execute(schema, introspectionQuery)
   else if (server) {
-    result = (
+    introspection = (
       await superagent
         .post(server)
         .type('json')
         .accept('json')
         .send({
-          query: typesQuery,
+          query: introspectionQuery,
         })
     ).body
   } else {
     throw new Error('schemaFile or server must be configured')
   }
-  const { data } = result
-  if (!data) throw new Error('failed to get introspection query data')
-  const {
-    __schema: { types },
-  } = data
+  if (introspection.errors) {
+    throw new Error(
+      `failed to get introspection data:\n${introspection.errors.join('\n')}`
+    )
+  }
+  return introspection.data
+}
+
+export default async function analyzeSchema(options: {
+  schemaFile?: string
+  schema?: graphql.GraphQLSchema
+  server?: string
+}): Promise<AnalyzeResult> {
+  const data = await getIntrospectionData(options)
+  const { schemaFile } = options
+  const schema = options.schema || graphql.buildClientSchema(data)
+
   const cwd = schemaFile ? path.dirname(schemaFile) : process.cwd()
-  return analyzeTypes(types, { cwd })
+  return {
+    analyzed: analyzeTypes(data, { cwd }),
+    schema,
+  }
 }
 
 const schemaFileTimestamps: Map<string, Date> = new Map()
-const schemaCache: Map<string, AnalyzedSchema> = new Map()
+const schemaCache: Map<string, AnalyzeResult> = new Map()
 
 /**
- * Uses execFileSync to run analyzeSchema synchronously,
+ * Uses execFileSync to analyze the schema synchronously,
  * since jscodeshift transforms unfortunately have to be sync right now
  */
 export function analyzeSchemaSync(options: {
   schemaFile?: string
   server?: string
-}): AnalyzedSchema {
+}): AnalyzeResult {
   const file = options.schemaFile
   if (file) {
     const timestamp = schemaFileTimestamps.get(file)
@@ -403,20 +340,30 @@ export function analyzeSchemaSync(options: {
     }
   }
 
-  const schema = flatted.parse(
+  const data = JSON.parse(
     execFileSync(
-      require.resolve('./runAnalyzeSchemaSync'),
-      [JSON.stringify({ ...options, target: __filename })],
+      require.resolve('./runSync'),
+      [
+        JSON.stringify({
+          ...options,
+          target: __filename,
+          method: 'getIntrospectionData',
+        }),
+      ],
       {
         encoding: 'utf8',
         maxBuffer: 256 * 1024 * 1024,
       }
     )
   )
+  const cwd = file ? path.dirname(file) : process.cwd()
+  const schema = graphql.buildClientSchema(data)
+  const analyzed = analyzeTypes(data, { cwd })
+  const result = { analyzed, schema }
   if (file) {
     const latest = fs.statSync(file).mtime
     schemaFileTimestamps.set(file, latest)
-    schemaCache.set(file, schema)
+    schemaCache.set(file, result)
   }
-  return schema
+  return result
 }

src/internal/config.ts

@@ -38,6 +38,10 @@ export type Config = {
    *   const data: QueryRenderProps<QueryData, QueryVariables> = useQuery(query, {variables: {id}})
    */
   useFunctionTypeArguments?: boolean
+  /**
+   * Whether to validate GraphQL queries
+   */
+  validate?: boolean
 }
 
 export type DefaultedConfig = {
@@ -77,7 +81,11 @@ export type DefaultedConfig = {
    *
    *   const data: QueryRenderProps<QueryData, QueryVariables> = useQuery(query, {variables: {id}})
    */
-  useFunctionTypeArguments?: boolean
+  useFunctionTypeArguments: boolean
+  /**
+   * Whether to validate GraphQL queries
+   */
+  validate: boolean
 }
 
 export function applyConfigDefaults(config: Config): DefaultedConfig {
@@ -87,6 +95,7 @@ export function applyConfigDefaults(config: Config): DefaultedConfig {
   const useReadOnlyTypes = config.useReadOnlyTypes ?? false
   const objectType = config.objectType || 'ambiguous'
   const useFunctionTypeArguments = config.useFunctionTypeArguments ?? true
+  const validate = config.validate ?? true
 
   const result = {
     schemaFile,
@@ -96,6 +105,7 @@ export function applyConfigDefaults(config: Config): DefaultedConfig {
     useReadOnlyTypes,
     objectType,
     useFunctionTypeArguments,
+    validate,
   }
 
   for (const key in config) {

src/internal/generateFlowTypesFromDocument.ts

@@ -45,15 +45,15 @@ type GeneratedTypes = {
   fragment: Record<string, TypeAlias>
 }
 
-export default function graphqlToFlow({
-  query,
+export default function generateFlowTypesFromDocument({
+  document,
   file,
   types,
   config: _config,
   getMutationFunction,
   j,
 }: {
-  query: string | graphql.DocumentNode
+  document: graphql.DocumentNode
   file: string
   types: Record<string, AnalyzedType>
   config: Config
@@ -217,9 +217,6 @@ export default function graphqlToFlow({
         .replace(/\..+$/, '')
     : null
 
-  const document: graphql.DocumentNode =
-    typeof query === 'string' ? (query = graphql.parse(query)) : query
-
   const fragments: Map<string, TypeAlias> = new Map()
   const statements: TypeAlias[] = []
   const generatedTypes: GeneratedTypes = {

src/internal/getConfigDirectives.ts

@@ -95,5 +95,11 @@ export default function getConfigDirectives(
       }
     }
   }
-  return { external, extract, objectType, useReadOnlyTypes, addTypename }
+  return {
+    external,
+    extract,
+    objectType,
+    useReadOnlyTypes,
+    addTypename,
+  }
 }