Add json-modern target and typeNodes to output

Adds a json-modern target to the codegen command that
is similar to the json target, but with the addition of
ast type nodes to the output.

Author: JakeDawkins

package-lock.json

@@ -0,0 +1,92 @@
+import { parse } from "graphql";
+
+import { loadSchema } from "../../loading";
+
+import { compileToIR } from "../";
+
+const schema = loadSchema(
+  require.resolve("../../../../../__fixtures__/starwars/schema.json")
+);
+
+describe("Compiling query documents to modern IR with typeNodes", () => {
+  it(`should print IR with typeNodes on fields`, () => {
+    const document = parse(`
+      query HeroName($episode: Episode) {
+        hero(episode: $episode) {
+          name
+          ...withId
+        }
+      }
+
+      query Search($text: String!) {
+        search(text: $text) {
+          ... on Character {
+            name
+          }
+        }
+      }
+
+      mutation CreateReviewForEpisode($episode: Episode!, $review: ReviewInput!) {
+        createReview(episode: $episode, review: $review) {
+          stars
+          commentary
+        }
+      }
+
+      fragment withId on Character {
+        id
+      }
+    `);
+
+    const { operations } = compileToIR(schema, document);
+
+    expect(
+      operations["HeroName"].selectionSet.selections[0].selectionSet
+        .selections[0].typeNode
+    ).toEqual({
+      kind: "NonNullType",
+      type: {
+        kind: "NamedType",
+        name: {
+          kind: "Name",
+          value: "String"
+        }
+      }
+    });
+
+    expect(operations["HeroName"].variables[0].typeNode).toEqual({
+      kind: "NamedType",
+      name: {
+        kind: "Name",
+        value: "Episode"
+      }
+    });
+
+    expect(operations["Search"].variables[0].typeNode).toEqual({
+      kind: "NonNullType",
+      type: {
+        kind: "NamedType",
+        name: {
+          kind: "Name",
+          value: "String"
+        }
+      }
+    });
+
+    expect(
+      operations["Search"].selectionSet.selections[0].selectionSet.selections[0]
+        .typeNode
+    ).toEqual({
+      kind: "NamedType",
+      name: { kind: "Name", value: "Character" }
+    });
+
+    expect(
+      operations["CreateReviewForEpisode"].selectionSet.selections[0]
+        .selectionSet.selections[0].typeNode
+    ).toEqual({
+      kind: "NonNullType",
+      type: { kind: "NamedType", name: { kind: "Name", value: "Int" } }
+    });
+  });
+});

packages/apollo-codegen-core/src/compiler/__tests__/index.ts

@@ -1,13 +1,6 @@
 import { stripIndent } from "common-tags";
 
-import {
-  parse,
-  isType,
-  GraphQLID,
-  GraphQLString,
-  GraphQLList,
-  GraphQLNonNull
-} from "graphql";
+import { parse } from "graphql";
 
 import { loadSchema } from "../../loading";
 

packages/apollo-codegen-core/src/compiler/__tests__/legacyIR.ts

@@ -22,7 +22,11 @@ import {
   GraphQLNonNull,
   isEnumType,
   isInputObjectType,
-  isScalarType
+  isScalarType,
+  NamedTypeNode,
+  ListTypeNode,
+  TypeNode,
+  parseType
 } from "graphql";
 
 import {
@@ -48,6 +52,7 @@ export interface CompilerOptions {
   useReadOnlyTypes?: boolean;
   suppressSwiftMultilineStringLiterals?: boolean;
   omitDeprecatedEnumCases?: boolean;
+  exposeTypeNodes?: boolean;
 }
 
 export interface CompilerContext {
@@ -65,6 +70,7 @@ export interface Operation {
   variables: {
     name: string;
     type: GraphQLType;
+    typeNode?: TypeNode;
   }[];
   filePath: string;
   source: string;
@@ -77,6 +83,7 @@ export interface Fragment {
   fragmentName: string;
   source: string;
   type: GraphQLCompositeType;
+  typeNode?: TypeNode;
   selectionSet: SelectionSet;
 }
 
@@ -89,6 +96,7 @@ export interface Argument {
   name: string;
   value: any;
   type?: GraphQLInputType;
+  typeNode?: TypeNode;
 }
 
 export type Selection =
@@ -104,6 +112,7 @@ export interface Field {
   alias?: string;
   args?: Argument[];
   type: GraphQLOutputType;
+  typeNode?: TypeNode;
   description?: string;
   isDeprecated?: boolean;
   deprecationReason?: string;
@@ -114,6 +123,7 @@ export interface Field {
 export interface TypeCondition {
   kind: "TypeCondition";
   type: GraphQLCompositeType;
+  typeNode?: TypeNode;
   selectionSet: SelectionSet;
 }
 
@@ -131,10 +141,23 @@ export interface FragmentSpread {
   selectionSet: SelectionSet;
 }
 
+export function stripProp(propName: string, obj: Object) {
+  let cloned = JSON.parse(JSON.stringify(obj));
+  for (let prop in cloned) {
+    if (prop === propName) delete cloned[prop];
+    else if (typeof cloned[prop] === "object") {
+      cloned[prop] = stripProp(propName, cloned[prop]);
+    }
+  }
+  return cloned;
+}
+
 export function compileToIR(
   schema: GraphQLSchema,
   document: DocumentNode,
-  options: CompilerOptions = {}
+  options: CompilerOptions = {
+    exposeTypeNodes: true
+  }
 ): CompilerContext {
   if (options.addTypename) {
     document = withTypenameFieldAddedWhereNeeded(document);
@@ -235,7 +258,15 @@ class Compiler {
         const name = node.variable.name.value;
         const type = typeFromAST(this.schema, node.type as NonNullTypeNode);
         this.addTypeUsed(getNamedType(type as GraphQLType));
-        return { name, type: type as GraphQLNonNull<any> };
+        const typeNode =
+          this.options.exposeTypeNodes && type
+            ? stripProp("loc", parseType(type.toString()))
+            : undefined;
+        return {
+          name,
+          type: type as GraphQLNonNull<any>,
+          typeNode
+        };
       }
     );
 
@@ -270,6 +301,10 @@ class Compiler {
       fragmentDefinition.typeCondition
     ) as GraphQLCompositeType;
 
+    const typeNode = this.options.exposeTypeNodes
+      ? stripProp("loc", parseType(type.toString()))
+      : undefined;
+
     return {
       fragmentName,
       filePath,
@@ -278,7 +313,8 @@ class Compiler {
       selectionSet: this.compileSelectionSet(
         fragmentDefinition.selectionSet,
         type
-      )
+      ),
+      typeNode
     };
   }
 
@@ -329,8 +365,11 @@ class Compiler {
         }
 
         const fieldType = fieldDef.type;
-        const unmodifiedFieldType = getNamedType(fieldType);
+        const typeNode = this.options.exposeTypeNodes
+          ? stripProp("loc", parseType(fieldType.toString()))
+          : undefined;
 
+        const unmodifiedFieldType = getNamedType(fieldType);
         this.addTypeUsed(unmodifiedFieldType);
 
         const { description, isDeprecated, deprecationReason } = fieldDef;
@@ -344,10 +383,16 @@ class Compiler {
                 const argDef = fieldDef.args.find(
                   argDef => argDef.name === arg.name.value
                 );
+                const argDefType = (argDef && argDef.type) || undefined;
+                const argDeftypeNode =
+                  this.options.exposeTypeNodes && argDefType
+                    ? stripProp("loc", parseType(argDefType.toString()))
+                    : undefined;
                 return {
                   name,
                   value: valueFromValueNode(arg.value),
-                  type: (argDef && argDef.type) || undefined
+                  type: argDefType,
+                  typeNode: argDeftypeNode
                 };
               })
             : undefined;
@@ -359,6 +404,7 @@ class Compiler {
           alias,
           args,
           type: fieldType,
+          typeNode,
           description:
             !isMetaFieldName(name) && description ? description : undefined,
           isDeprecated,
@@ -391,9 +437,13 @@ class Compiler {
         const possibleTypesForTypeCondition = this.possibleTypesForType(
           type
         ).filter(type => possibleTypes.includes(type));
+        const typeConditiontypeNode = this.options.exposeTypeNodes
+          ? stripProp("loc", parseType(type.toString()))
+          : undefined;
         return {
           kind: "TypeCondition",
           type,
+          typeNode: typeConditiontypeNode,
           selectionSet: this.compileSelectionSet(
             selectionNode.selectionSet,
             type,

packages/apollo-codegen-core/src/compiler/index.ts

@@ -29,6 +29,7 @@ export interface CompilerOptions {
   customScalarsPrefix?: string;
   namespace?: string;
   generateOperationIds?: boolean;
+  exposeRawTypes?: boolean;
 }
 
 export interface LegacyCompilerContext {
@@ -104,7 +105,10 @@ export interface Argument {
 export function compileToLegacyIR(
   schema: GraphQLSchema,
   document: DocumentNode,
-  options: CompilerOptions = { mergeInFieldsFromFragmentSpreads: true }
+  options: CompilerOptions = {
+    mergeInFieldsFromFragmentSpreads: true,
+    exposeRawTypes: false
+  }
 ): LegacyCompilerContext {
   const context = compileToIR(schema, document, options);
   const transformer = new LegacyIRTransformer(context, options);

packages/apollo-codegen-core/src/compiler/legacyIR.ts

@@ -10,8 +10,11 @@ import {
 } from "graphql";
 
 import { LegacyCompilerContext } from "./compiler/legacyIR";
+import { CompilerContext } from "./compiler";
 
-export default function serializeToJSON(context: LegacyCompilerContext) {
+export default function serializeToJSON(
+  context: LegacyCompilerContext | CompilerContext
+) {
   return serializeAST(
     {
       operations: Object.values(context.operations),