Support extensions in schema

.npmignore

@@ -4,6 +4,5 @@
 # except these
 !lib/**/*
 !src/**/*
-!package-lock.json
 !package.json
 !README.md

package.json

@@ -22,25 +22,26 @@
   "devDependencies": {
     "@playlyfe/gql": "2.3.2",
     "@types/fs-extra": "4.0.4",
-    "@types/graphql": "0.11.5",
+    "@types/graphql": "^14.5.0",
     "@types/jest": "21.1.5",
-    "@types/node": "8.0.50",
+    "@types/lodash": "^4.14.149",
+    "@types/node": "^13.9.2",
     "@types/yargs": "^11.0.0",
     "del-cli": "^2.0.0",
     "fs-extra": "4.0.2",
-    "graphql": "0.11.7",
-    "graphql-tools": "2.7.2",
+    "graphql": "^14.6.0",
     "jest": "22.4.3",
-    "lodash": "^4.17.13",
     "ts-jest": "22.4.4",
     "tslint": "5.8.0",
-    "typescript": "2.9.2"
+    "typescript": "^3.8.3"
   },
   "dependencies": {
+    "graphql-tools": "^4.0.7",
+    "lodash": "^4.17.15",
     "yargs": "^11.0.0"
   },
   "peerDependencies": {
-    "graphql": "*",
+    "graphql": ">= 0.12",
     "typescript": "*"
   },
   "jest": {

src/__tests__/__snapshots__/schemaExtendDeclarations.test.ts.snap

@@ -0,0 +1,49 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`schema extension declaration should generate if schema is a valid graphql schema 1`] = `
+"/* tslint:disable */
+/* eslint-disable */
+import { GraphQLResolveInfo } from 'graphql';
+/**
+ * This file is auto-generated by @raraujo/graphql-schema-typescript
+ * Please note that any changes in this file may be overwritten
+ */
+
+
+/*******************************
+ *                             *
+ *          TYPE DEFS          *
+ *                             *
+ *******************************/
+export interface GQLQuery {
+  test: string;
+  foo?: string;
+}
+
+/*********************************
+ *                               *
+ *         TYPE RESOLVERS        *
+ *                               *
+ *********************************/
+/**
+ * This interface define the shape of your resolver
+ * Note that this type is designed to be compatible with graphql-tools resolvers
+ * However, you can still use other generated interfaces to make your resolver type-safed
+ */
+export interface GQLResolver {
+  Query?: GQLQueryTypeResolver;
+}
+export interface GQLQueryTypeResolver<TParent = any> {
+  test?: QueryToTestResolver<TParent>;
+  foo?: QueryToFooResolver<TParent>;
+}
+
+export interface QueryToTestResolver<TParent = any, TResult = any> {
+  (parent: TParent, args: {}, context: any, info: GraphQLResolveInfo): TResult;
+}
+
+export interface QueryToFooResolver<TParent = any, TResult = any> {
+  (parent: TParent, args: {}, context: any, info: GraphQLResolveInfo): TResult;
+}
+"
+`;

src/__tests__/schemaExtendDeclarations.test.ts

@@ -0,0 +1,12 @@
+import * as path from 'path';
+import { generateTypeScriptTypes } from '..';
+import { executeApiTest } from './testUtils';
+
+describe('schema extension declaration', () => {
+
+    it('should generate if schema is a valid graphql schema', async () => {
+        const schemaStr = `schema { query: Query } type Query { test: String! } extend type Query { foo: String }`;
+        const generated = await executeApiTest('schemaString.ts', {}, schemaStr);
+        expect(generated).toEqual(expect.stringContaining('foo?: string'));
+    });
+});

src/__tests__/testSchema/index.ts

@@ -1,12 +1,13 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { makeExecutableSchema } from 'graphql-tools';
-import { GraphQLSchema, introspectionQuery, graphql } from 'graphql';
+import { GraphQLSchema } from 'graphql';
 
 const gqlFiles = fs.readdirSync(__dirname).filter(f => f.endsWith('.gql') || f.endsWith('.graphql'));
 
 const typeDefs = gqlFiles.map(filePath => fs.readFileSync(path.join(__dirname, filePath), 'utf-8'));
 
 export const testSchema: GraphQLSchema = makeExecutableSchema({
-    typeDefs: typeDefs
+    typeDefs: typeDefs,
+    resolverValidationOptions: {requireResolversForResolveType: false}
 });

src/__tests__/testUtils.ts

@@ -10,8 +10,8 @@ export const executeCommand = (command: string, options?: childProcess.ExecOptio
     return new Promise((resolve, reject) => {
         const process = childProcess.exec(command, options);
 
-        process.stdout.on('data', console.log);
-        process.stderr.on('data', console.error);
+        process.stdout!.on('data', console.log);
+        process.stderr!.on('data', console.error);
 
         process.on('close', (exitCode: number) => {
             if (exitCode !== 0) {
@@ -28,7 +28,7 @@ export const executeCommand = (command: string, options?: childProcess.ExecOptio
 };
 
 /** Function that count occurrences of a substring in a string;
- * @param {String} string               The string
+ * @param {String} str                  The string
  * @param {String} subString            The sub string to search for
  * @param {Boolean} [allowOverlapping]  Optional. (Default:false)
  *
@@ -44,7 +44,7 @@ export const occurrences = (str: string, subString: string, allowOverlapping: bo
         return (str.length + 1);
     }
 
-    var n = 0,
+    let n = 0,
         pos = 0,
         step = allowOverlapping ? 1 : subString.length;
 
@@ -63,7 +63,7 @@ export const occurrences = (str: string, subString: string, allowOverlapping: bo
 export const OUTPUT_FOLDER = path.join(__dirname, 'generatedTypes');
 export const executeApiTest = async (
     outputFile: string,
-    options: GenerateTypescriptOptions,
+    options: Partial<GenerateTypescriptOptions>,
     schema?: GraphQLSchema | string
 ): Promise<string> => {
     // prepare output folder
@@ -73,11 +73,11 @@ export const executeApiTest = async (
     const outputPath = path.join(OUTPUT_FOLDER, outputFile);
 
     // run api function
-    await generateTypeScriptTypes(schema || testSchema, outputPath, options);
+    generateTypeScriptTypes(schema || testSchema, outputPath, options as GenerateTypescriptOptions);
 
     // ensure no error on tsc
     const generated = fs.readFileSync(outputPath, 'utf-8');
-    await executeCommand(`tsc --noEmit --lib es6,esnext.asynciterable --target es5 ${outputPath}`);
+    await executeCommand(`yarn -s tsc --noEmit --lib es6,esnext.asynciterable --target es5 ${outputPath}`);
 
     // snapshot
     expect(generated).toMatchSnapshot();

src/cli.ts

@@ -101,7 +101,7 @@ yargs
         async argv => {
             const { folderPath, output } = argv;
 
-            const options: GenerateTypescriptOptions = {};
+            const options: Partial<GenerateTypescriptOptions> = {};
             options[globalOpt] = argv[globalOpt];
             options[typePrefix] = argv[typePrefix];
             options[namespaceOpt] = argv[namespaceOpt];
@@ -116,7 +116,7 @@ yargs
             options[noStringEnum] = argv[noStringEnum];
             options[optionalResolverInfo] = argv[optionalResolverInfo];
 
-            await generateTypeScriptTypes(folderPath, path.resolve(output), options);
+            generateTypeScriptTypes(folderPath, path.resolve(output), options as GenerateTypescriptOptions);
             if (process.env.NODE_ENV !== 'test') {
                 console.log(`Typescript generated at: ${output}`);
             }

src/index.ts

@@ -1,11 +1,10 @@
 import * as fs from 'fs';
 import * as path from 'path';
-import { GraphQLSchema, buildSchema } from 'graphql';
+import { GraphQLSchema } from 'graphql';
 import { GenerateTypescriptOptions, defaultOptions } from './types';
 import { TSResolverGenerator, GenerateResolversResult } from './typescriptResolverGenerator';
 import { TypeScriptGenerator } from './typescriptGenerator';
-import { formatTabSpace, introspectSchema, introspectSchemaViaLocalFile } from './utils';
-import { isString } from 'util';
+import { formatTabSpace, introspectSchema, introspectSchemaStr, introspectSchemaViaLocalFile } from './utils';
 import { IntrospectionQuery } from 'graphql/utilities/introspectionQuery';
 
 export { GenerateTypescriptOptions } from './types';
@@ -36,21 +35,21 @@ const typeResolversDecoration = [
     ' *********************************/'
 ];
 
-export const generateTSTypesAsString = async (
+export const generateTSTypesAsString = (
     schema: GraphQLSchema | string,
     outputPath: string,
     options: GenerateTypescriptOptions
-): Promise<string> => {
+): string => {
     const mergedOptions = { ...defaultOptions, ...options };
 
-    let introspectResult: IntrospectionQuery;
-    if (isString(schema)) {
+    let introspectResult: IntrospectionQuery | null = null;
+    if (typeof schema === 'string') {
         // is is a path to schema folder?
         try {
             const schemaPath = path.resolve(schema);
             const exists = fs.existsSync(schemaPath);
             if (exists) {
-                introspectResult = await introspectSchemaViaLocalFile(schemaPath);
+                introspectResult = introspectSchemaViaLocalFile(schemaPath);
             }
         } catch {
             // fall-through in case the provided string is a graphql definition,
@@ -59,22 +58,17 @@ export const generateTSTypesAsString = async (
 
         // it's not a folder, maybe it's a schema definition
         if (!introspectResult) {
-            const schemaViaStr = buildSchema(schema);
-            introspectResult = await introspectSchema(schemaViaStr);
+            introspectResult = introspectSchemaStr(schema);
         }
     } else {
-        introspectResult = await introspectSchema(schema);
+        introspectResult = introspectSchema(schema);
     }
 
     const tsGenerator = new TypeScriptGenerator(mergedOptions, introspectResult, outputPath);
-    const typeDefs = await tsGenerator.generate();
+    const typeDefs = tsGenerator.generate();
 
-    let typeResolvers: GenerateResolversResult = {
-        body: [],
-        importHeader: []
-    };
     const tsResolverGenerator = new TSResolverGenerator(mergedOptions, introspectResult);
-    typeResolvers = await tsResolverGenerator.generate();
+    const typeResolvers = tsResolverGenerator.generate();
 
     let header = [...typeResolvers.importHeader, jsDoc];
 
@@ -108,11 +102,11 @@ export const generateTSTypesAsString = async (
     return formatted.join('\n');
 };
 
-export async function generateTypeScriptTypes(
+export function generateTypeScriptTypes(
     schema: GraphQLSchema | string,
     outputPath: string,
     options: GenerateTypescriptOptions = defaultOptions
 ) {
-    const content = await generateTSTypesAsString(schema, outputPath, options);
+    const content = generateTSTypesAsString(schema, outputPath, options);
     fs.writeFileSync(outputPath, content, 'utf-8');
 }

src/types.ts

@@ -7,10 +7,10 @@ export interface GenerateTypescriptOptions {
     };
 
     /** Tab format, default to 2 */
-    tabSpaces?: number;
+    tabSpaces: number;
 
     /** A prefix to every generated types. Default to GQL */
-    typePrefix?: string;
+    typePrefix: string;
 
     /** Generate types as global */
     global?: boolean;

src/typescriptGenerator.ts

@@ -15,9 +15,8 @@ import {
     IntrospectionInputObjectType,
     IntrospectionInterfaceType,
     IntrospectionQuery,
-    IntrospectionField,
-    IntrospectionInputValue
 } from 'graphql';
+import { IntrospectionField, IntrospectionInputValue } from 'graphql/utilities/introspectionQuery';
 
 export class TypeScriptGenerator {
 
@@ -27,15 +26,15 @@ export class TypeScriptGenerator {
         protected outputPath: string
     ) { }
 
-    public async generate(): Promise<string[]> {
+    public generate(): string[] {
         const { introspectResult } = this;
         const gqlTypes = introspectResult.__schema.types.filter(type => !isBuiltinType(type));
 
         return gqlTypes.reduce<string[]>(
             (prevTypescriptDefs, gqlType) => {
 
                 const jsDoc = descriptionToJSDoc({ description: gqlType.description });
-                let typeScriptDefs: string[] = [].concat(jsDoc);
+                let typeScriptDefs = jsDoc.slice(0);
 
                 switch (gqlType.kind) {
                     case 'SCALAR': {
@@ -138,15 +137,15 @@ export class TypeScriptGenerator {
         if (this.options.enumsAsPascalCase) {
             return pascalCase(graphQlName);
         } else {
-            return graphQlName;            
+            return graphQlName;
         }
     }
 
     private generateObjectType(
         objectType: IntrospectionObjectType | IntrospectionInputObjectType | IntrospectionInterfaceType,
         allGQLTypes: IntrospectionType[]
     ): string[] {
-        const fields: (IntrospectionInputValue | IntrospectionField)[]
+        const fields: ReadonlyArray<IntrospectionInputValue | IntrospectionField>
             = objectType.kind === 'INPUT_OBJECT' ? objectType.inputFields : objectType.fields;
 
         const extendTypes: string[] = objectType.kind === 'OBJECT'
@@ -161,15 +160,14 @@ export class TypeScriptGenerator {
             []
         );
 
-        const objectFields = fields.reduce<string[]>(
-            (prevTypescriptDefs, field, index) => {
-
+        const objectFields = fields.reduce(
+            (prevTypescriptDefs, field) => {
                 if (extendFields.indexOf(field.name) !== -1 && this.options.minimizeInterfaceImplementation) {
                     return prevTypescriptDefs;
                 }
 
                 const fieldJsDoc = descriptionToJSDoc(field);
-                const { fieldName, fieldType } = createFieldRef(field, this.options.typePrefix, this.options.strictNulls);
+                const { fieldName, fieldType } = createFieldRef(field, this.options.typePrefix, !!this.options.strictNulls);
                 const fieldNameAndType = `${fieldName}: ${fieldType};`;
                 let typescriptDefs = [...fieldJsDoc, fieldNameAndType];
 
@@ -180,7 +178,7 @@ export class TypeScriptGenerator {
                 return prevTypescriptDefs.concat(typescriptDefs);
 
             },
-            []
+            [] as string[]
         );
 
         const possibleTypeNames: string[] = [];

src/typescriptResolverGenerator.ts

@@ -28,9 +28,9 @@ export class TSResolverGenerator {
     } = {};
     protected contextType: string;
 
-    protected queryType?: IntrospectionNamedTypeRef;
-    protected mutationType?: IntrospectionNamedTypeRef;
-    protected subscriptionType?: IntrospectionNamedTypeRef;
+    protected queryType?: IntrospectionNamedTypeRef<IntrospectionObjectType> | null;
+    protected mutationType?: IntrospectionNamedTypeRef | null;
+    protected subscriptionType?: IntrospectionNamedTypeRef<IntrospectionObjectType> | null;
 
     constructor(
         protected options: GenerateTypescriptOptions,
@@ -42,7 +42,7 @@ export class TSResolverGenerator {
         }
     }
 
-    public async generate(): Promise<GenerateResolversResult> {
+    public generate(): GenerateResolversResult {
         const { introspectionResult } = this;
         const gqlTypes = introspectionResult.__schema.types.filter(type => !isBuiltinType(type));
         this.queryType = introspectionResult.__schema.queryType;