[Feature] Support lexical parser options (#567)

Add feature supporting lexical parser options

This adds the ability to specify `parseOptions` through makeExecutableSchema
into graphql.parse - unlocking finer control of lexical options when
building a schema.

Author: coleturner

.travis.yml

@@ -22,3 +22,4 @@ sudo: false
 env:
   - GRAPHQL_VERSION='^0.11'
   - GRAPHQL_VERSION='^0.12'
+  - GRAPHQL_VERSION='^0.13'

CHANGELOG.md

@@ -3,6 +3,8 @@
 ### vNEXT
 
 * Make iterall a runtime dependency [PR #627](https://github.com/apollographql/graphql-tools/pull/627)
+* Added support for lexical parser options [PR #567](https://github.com/apollographql/graphql-tools/pull/567)
+* Support `graphql@^0.13.0` [PR #567](https://github.com/apollographql/graphql-tools/pull/567)
 
 ### v2.20.2
 

docs/source/generate-schema.md

@@ -336,6 +336,8 @@ const jsSchema = makeExecutableSchema({
 
 - `logger` is an optional argument, which can be used to print errors to the server console that are usually swallowed by GraphQL. The `logger` argument should be an object with a `log` function, eg. `const logger = { log: (e) => console.log(e) }`
 
+- `parseOptions` is an optional argument which allows customization of parse when specifying `typeDefs` as a string.
+
 - `allowUndefinedInResolve` is an optional argument, which is `true` by default. When set to `false`, causes your resolve functions to throw errors if they return undefined, which can help make debugging easier.
 
 - `resolverValidationOptions` is an optional argument which accepts an object of the following shape: `{ requireResolversForArgs, requireResolversForNonScalar }`.

package.json

@@ -48,14 +48,14 @@
   },
   "homepage": "https://github.com/apollostack/graphql-tools#readme",
   "dependencies": {
-    "apollo-link": "^1.0.0",
+    "apollo-link": "^1.1.0",
     "apollo-utilities": "^1.0.1",
     "deprecated-decorator": "^0.1.6",
-    "iterall": "^1.1.3",    
+    "iterall": "^1.1.3",
     "uuid": "^3.1.0"
   },
   "peerDependencies": {
-    "graphql": "^0.11.0 || ^0.12.0"
+    "graphql": "^0.11.0 || ^0.12.0 || ^0.13.0"
   },
   "devDependencies": {
     "@types/chai": "4.0.10",
@@ -67,8 +67,8 @@
     "body-parser": "^1.18.2",
     "chai": "^4.1.2",
     "express": "^4.16.2",
-    "graphql": "^0.12.3",
-    "graphql-subscriptions": "^0.5.6",
+    "graphql": "^0.13.0",
+    "graphql-subscriptions": "^0.5.7",
     "graphql-type-json": "^0.1.4",
     "istanbul": "^0.4.5",
     "mocha": "^4.0.1",

src/Interfaces.ts

@@ -78,6 +78,7 @@ export interface IExecutableSchemaDefinition {
   allowUndefinedInResolve?: boolean;
   resolverValidationOptions?: IResolverValidationOptions;
   directiveResolvers?: IDirectiveResolvers<any, any>;
+  parseOptions?: GraphQLParseOptions;
 }
 
 export type IFieldIteratorFn = (
@@ -122,3 +123,10 @@ export interface IMockServer {
 }
 
 export type ResolveType<T extends GraphQLType> = (type: T) => T;
+
+export type GraphQLParseOptions = {
+  noLocation?: boolean,
+  allowLegacySDLEmptyFields?: boolean,
+  allowLegacySDLImplementsInterfaces?: boolean,
+  experimentalFragmentVariables?: boolean,
+};

src/schemaGenerator.ts

@@ -41,6 +41,7 @@ import {
   IResolverValidationOptions,
   IDirectiveResolvers,
   UnitOrList,
+  GraphQLParseOptions,
 } from './Interfaces';
 
 import { deprecated } from 'deprecated-decorator';
@@ -67,6 +68,7 @@ function _generateSchema(
   allowUndefinedInResolve: boolean,
   resolverValidationOptions: IResolverValidationOptions,
   directiveResolvers: IDirectiveResolvers<any, any>,
+  parseOptions: GraphQLParseOptions,
 ) {
   if (typeof resolverValidationOptions !== 'object') {
     throw new SchemaError(
@@ -88,7 +90,7 @@ function _generateSchema(
 
   // TODO: check that typeDefinitions is either string or array of strings
 
-  const schema = buildSchemaFromTypeDefinitions(typeDefinitions);
+  const schema = buildSchemaFromTypeDefinitions(typeDefinitions, parseOptions);
 
   addResolveFunctionsToSchema(schema, resolvers, resolverValidationOptions);
 
@@ -117,6 +119,7 @@ function makeExecutableSchema({
   allowUndefinedInResolve = true,
   resolverValidationOptions = {},
   directiveResolvers = null,
+  parseOptions = {},
 }: IExecutableSchemaDefinition) {
   const jsSchema = _generateSchema(
     typeDefs,
@@ -125,6 +128,7 @@ function makeExecutableSchema({
     allowUndefinedInResolve,
     resolverValidationOptions,
     directiveResolvers,
+    parseOptions,
   );
   if (typeof resolvers['__schema'] === 'function') {
     // TODO a bit of a hack now, better rewrite generateSchema to attach it there.
@@ -186,6 +190,7 @@ function concatenateTypeDefs(
 
 function buildSchemaFromTypeDefinitions(
   typeDefinitions: ITypeDefinitions,
+  parseOptions?: GraphQLParseOptions,
 ): GraphQLSchema {
   // TODO: accept only array here, otherwise interfaces get confusing.
   let myDefinitions = typeDefinitions;
@@ -204,7 +209,7 @@ function buildSchemaFromTypeDefinitions(
   }
 
   if (typeof myDefinitions === 'string') {
-    astDocument = parse(myDefinitions);
+    astDocument = parse(myDefinitions, parseOptions);
   }
 
   const backcompatOptions = { commentDescriptions: true };

src/test/testSchemaGenerator.ts

@@ -701,8 +701,8 @@ describe('generating schema from shorthand', () => {
       RootQuery: {
         numberOfSpecies() {
           return 1;
-        }
-      }
+        },
+      },
     };
 
     const testQuery = `{
@@ -983,8 +983,8 @@ describe('generating schema from shorthand', () => {
           RED: '#EA3232',
         },
         NumericEnum: {
-          TEST: 1
-        }
+          TEST: 1,
+        },
       };
 
       const jsSchema = makeExecutableSchema({
@@ -994,7 +994,9 @@ describe('generating schema from shorthand', () => {
 
       expect(jsSchema.getQueryType().name).to.equal('Query');
       expect(jsSchema.getType('Color')).to.be.an.instanceof(GraphQLEnumType);
-      expect(jsSchema.getType('NumericEnum')).to.be.an.instanceof(GraphQLEnumType);
+      expect(jsSchema.getType('NumericEnum')).to.be.an.instanceof(
+        GraphQLEnumType,
+      );
     });
 
     it('supports passing the value for a GraphQLEnumType in resolveFunctions', () => {
@@ -1035,7 +1037,7 @@ describe('generating schema from shorthand', () => {
           },
           numericEnum() {
             return 1;
-          }
+          },
         },
       };
 
@@ -2393,3 +2395,126 @@ describe('attachDirectiveResolvers on field', () => {
     );
   });
 });
+
+describe('can specify lexical parser options', () => {
+  it("can specify 'noLocation' option", () => {
+    const schema = makeExecutableSchema({
+      typeDefs: `
+        type RootQuery {
+          test: String
+        }
+        schema {
+          query: RootQuery
+        }
+      `,
+      resolvers: {},
+      parseOptions: {
+        noLocation: true,
+      },
+    });
+
+    expect(schema.astNode.loc).to.equal(undefined);
+  });
+
+  if (['^0.11', '^0.12'].indexOf(process.env.GRAPHQL_VERSION) === -1) {
+    it("can specify 'allowLegacySDLEmptyFields' option", () => {
+      return expect(() => {
+        makeExecutableSchema({
+          typeDefs: `
+            type RootQuery {
+            }
+            schema {
+              query: RootQuery
+            }
+          `,
+          resolvers: {},
+          parseOptions: {
+            allowLegacySDLEmptyFields: true,
+          },
+        });
+      }).to.not.throw();
+    });
+
+    it("can specify 'allowLegacySDLImplementsInterfaces' option", () => {
+      const typeDefs = `
+        interface A {
+          hello: String
+        }
+        interface B {
+          world: String
+        }
+        type RootQuery implements A, B {
+          hello: String
+          world: String
+        }
+        schema {
+          query: RootQuery
+        }
+      `;
+
+      const resolvers = {};
+
+      expect(() => {
+        makeExecutableSchema({
+          typeDefs,
+          resolvers,
+          parseOptions: {
+            allowLegacySDLImplementsInterfaces: true,
+          },
+        });
+      }).to.not.throw();
+
+      expect(() => {
+        makeExecutableSchema({
+          typeDefs,
+          resolvers,
+          parseOptions: {
+            allowLegacySDLImplementsInterfaces: false,
+          },
+        });
+      }).to.throw('Syntax Error: Unexpected Name');
+    });
+  }
+
+  if (process.env.GRAPHQL_VERSION !== '^0.11') {
+    it("can specify 'experimentalFragmentVariables' option", () => {
+      const typeDefs = `
+        type Hello {
+          world(phrase: String): String
+        }
+
+        fragment hello($phrase: String = "world") on Hello {
+          world(phrase: $phrase)
+        }
+
+        type RootQuery {
+          hello: Hello
+        }
+
+        schema {
+          query: RootQuery
+        }
+      `;
+
+      const resolvers = {
+        RootQuery: {
+          hello() {
+            return {
+              world: (phrase: string) => `hello ${phrase}`,
+            };
+          },
+        },
+      };
+
+      expect(() => {
+        makeExecutableSchema({
+          typeDefs,
+          resolvers,
+          parseOptions: {
+            experimentalFragmentVariables: true,
+          },
+        });
+      }).to.not.throw();
+    });
+  }
+});

src/test/testingSchemas.ts

@@ -28,8 +28,8 @@ export type Property = {
 export type Product = {
   id: string;
   price?: number;
-  url?: string,
-  type: string,
+  url?: string;
+  type: string;
 };
 
 export type Booking = {
@@ -369,29 +369,50 @@ const propertyResolvers: IResolvers = {
   },
 };
 
-const productTypeDefs = `
-  interface Product {
+let DownloadableProduct = `
+  type DownloadableProduct implements Product & Downloadable {
     id: ID!
+    url: String!
   }
+`;
 
-  interface Sellable {
+let SimpleProduct = `type SimpleProduct implements Product & Sellable {
+    id: ID!
     price: Int!
   }
+`;
 
-  interface Downloadable {
-    url: String!
-  }
+if (['^0.11', '^0.12'].indexOf(process.env.GRAPHQL_VERSION) !== -1) {
+  DownloadableProduct = `
+    type DownloadableProduct implements Product, Downloadable {
+      id: ID!
+      url: String!
+    }
+  `;
 
-  type SimpleProduct implements Product, Sellable {
+  SimpleProduct = `type SimpleProduct implements Product, Sellable {
+      id: ID!
+      price: Int!
+    }
+  `;
+}
+
+const productTypeDefs = `
+  interface Product {
     id: ID!
+  }
+
+  interface Sellable {
     price: Int!
   }
 
-  type DownloadableProduct implements Product, Downloadable {
-    id: ID!
+  interface Downloadable {
     url: String!
   }
 
+  ${SimpleProduct}
+  ${DownloadableProduct}
+
   type Query {
     products: [Product]
   }