@khanacademy/graphql-flow 0.0.1

package/src/__test__/graphql-flow.test.js

@@ -0,0 +1,364 @@
+// @flow
+
+/**
+ * Tests for our graphql flow generation!
+ */
+
+import type {IntrospectionQuery, DocumentNode} from 'graphql';
+import type {Schema, Options} from '../types';
+import {buildSchema, getIntrospectionQuery, graphqlSync} from 'graphql';
+import fs from 'fs';
+const {documentToFlowTypes} = require('..');
+const {schemaFromIntrospectionData} = require('../schemaFromIntrospectionData');
+
+// This allows us to "snapshot" a string cleanly.
+/* eslint-disable flowtype-errors/uncovered */
+expect.addSnapshotSerializer({
+    test: (value) => value && typeof value === 'string',
+    print: (value, _, __) => value,
+});
+/* eslint-enable flowtype-errors/uncovered */
+
+const generateTestSchema = (): Schema => {
+    const raw = fs.readFileSync(__dirname + '/example-schema.graphql', 'utf8');
+    const queryResponse = graphqlSync(
+        buildSchema(raw),
+        getIntrospectionQuery({descriptions: true}),
+    );
+    if (!queryResponse.data) {
+        throw new Error(
+            'Failed to parse example schema: ' + JSON.stringify(queryResponse),
+        );
+    }
+    return schemaFromIntrospectionData(
+        // eslint-disable-next-line flowtype-errors/uncovered
+        ((queryResponse.data: any): IntrospectionQuery),
+    );
+};
+
+const exampleSchema = generateTestSchema();
+
+const rawQueryToFlowTypes = (query: string, options?: Options): string => {
+    // We need the "requireActual" because we mock graphql-tag in jest-setup.js
+    // eslint-disable-next-line flowtype-errors/uncovered
+    const gql: (string) => DocumentNode = jest.requireActual('graphql-tag');
+    const node = gql(query);
+    return documentToFlowTypes(node, exampleSchema, {
+        scalars: {PositiveNumber: 'number'},
+        ...options,
+    })
+        .map(({code}) => code)
+        .join('\n\n');
+};
+
+describe('graphql-flow generation', () => {
+    it('should work with a basic query', () => {
+        const result = rawQueryToFlowTypes(`
+            query SomeQuery {
+                human(id: "Han Solo") {
+                    id
+                    name
+                    homePlanet
+                    friends {
+                        name
+                    }
+                }
+            }
+        `);
+
+        expect(result).toMatchInlineSnapshot(`
+            export type SomeQueryType = {|
+                variables: {||},
+                response: {|
+
+              /** A human character*/
+              human: ?{|
+                id: string,
+
+                /** The person's name*/
+                name: ?string,
+                homePlanet: ?string,
+                friends: ?$ReadOnlyArray<?{|
+                  name: ?string
+                |}>,
+              |}
+            |}
+            |};
+        `);
+    });
+
+    it('renames', () => {
+        const result = rawQueryToFlowTypes(`
+            query SomeQuery {
+                human(id: "Han Solo") {
+                    notDead: alive
+                }
+            }
+        `);
+
+        expect(result).toMatchInlineSnapshot(`
+            export type SomeQueryType = {|
+                variables: {||},
+                response: {|
+
+              /** A human character*/
+              human: ?{|
+                notDead: ?boolean
+              |}
+            |}
+            |};
+        `);
+    });
+
+    it('should work with unions', () => {
+        const result = rawQueryToFlowTypes(`
+            query SomeQuery {
+                friend(id: "Han Solo") {
+                    __typename
+                    ... on Human {
+                        id
+                        hands
+                    }
+                    ... on Droid {
+                        primaryFunction
+                    }
+                }
+            }
+        `);
+        expect(result).toMatchInlineSnapshot(`
+            export type SomeQueryType = {|
+                variables: {||},
+                response: {|
+              friend: ?({|
+                __typename: "Human",
+                id: string,
+                hands: ?number,
+              |} | {|
+                __typename: "Droid",
+
+                /** The robot's primary function*/
+                primaryFunction: ?string,
+              |} | {|
+                __typename: "Animal"
+              |})
+            |}
+            |};
+        `);
+    });
+
+    it('should work with fragments on interface', () => {
+        const result = rawQueryToFlowTypes(`
+            query SomeQuery {
+                human(id: "Han Solo") {
+                    id
+                    name
+                    homePlanet
+                    hands
+                    alive
+                    friends {
+                        ...Profile
+                        ... on Human {
+                            hands
+                        }
+                    }
+                }
+            }
+
+            fragment Profile on Character {
+                __typename
+                id
+                name
+                friends {
+                    id
+                }
+                appearsIn
+            }
+        `);
+
+        expect(result).toMatchInlineSnapshot(`
+            export type SomeQueryType = {|
+                variables: {||},
+                response: {|
+
+              /** A human character*/
+              human: ?{|
+                id: string,
+
+                /** The person's name*/
+                name: ?string,
+                homePlanet: ?string,
+                hands: ?number,
+                alive: ?boolean,
+                friends: ?$ReadOnlyArray<?({|
+                  __typename: "Human",
+                  id: string,
+                  name: ?string,
+                  friends: ?$ReadOnlyArray<?{|
+                    id: string
+                  |}>,
+                  appearsIn: ?$ReadOnlyArray<
+                  /** - NEW_HOPE
+                  - EMPIRE
+                  - JEDI*/
+                  ?("NEW_HOPE" | "EMPIRE" | "JEDI")>,
+                  hands: ?number,
+                |} | {|
+                  __typename: "Droid",
+                  id: string,
+                  name: ?string,
+                  friends: ?$ReadOnlyArray<?{|
+                    id: string
+                  |}>,
+                  appearsIn: ?$ReadOnlyArray<
+                  /** - NEW_HOPE
+                  - EMPIRE
+                  - JEDI*/
+                  ?("NEW_HOPE" | "EMPIRE" | "JEDI")>,
+                |})>,
+              |}
+            |}
+            |};
+        `);
+    });
+
+    it('should work with a readOnlyArray turned off', () => {
+        const result = rawQueryToFlowTypes(
+            `
+            query SomeQuery {
+                human(id: "Han Solo") {
+                    friends {
+                        name
+                    }
+                }
+            }
+        `,
+            {readOnlyArray: false},
+        );
+
+        expect(result).toMatchInlineSnapshot(`
+            export type SomeQueryType = {|
+                variables: {||},
+                response: {|
+
+              /** A human character*/
+              human: ?{|
+                friends: ?Array<?{|
+                  name: ?string
+                |}>
+              |}
+            |}
+            |};
+        `);
+    });
+
+    describe('Object properties', () => {
+        it('should reject invalid field', () => {
+            expect(() =>
+                rawQueryToFlowTypes(`
+                    query SomeQuery {
+                        human(id: "Me") {
+                            invalidField
+                        }
+                    }
+                `),
+            ).toThrowErrorMatchingInlineSnapshot(
+                `Graphql-flow type generation failed! Unknown field 'invalidField' for type 'Human'`,
+            );
+        });
+
+        it('should reject an unknown fragment', () => {
+            expect(() =>
+                rawQueryToFlowTypes(`
+            query SomeQuery {
+                human(id: "Me") {
+                    ...UnknownFragment
+                }
+            }
+            `),
+            ).toThrowErrorMatchingInlineSnapshot(
+                `Graphql-flow type generation failed! No fragment named 'UnknownFragment'. Did you forget to include it in the template literal?`,
+            );
+        });
+    });
+
+    describe('Input variables', () => {
+        it('should generate a variables type', () => {
+            const result = rawQueryToFlowTypes(
+                `query SomeQuery($id: String!, $episode: Episode) {
+                    human(id: $id) {
+                        friends {
+                            name
+                        }
+                    }
+                    hero(episode: $episode) {
+                        name
+                    }
+                }`,
+                {readOnlyArray: false},
+            );
+
+            expect(result).toMatchInlineSnapshot(`
+                export type SomeQueryType = {|
+                    variables: {|
+                  id: string,
+
+                  /** - NEW_HOPE
+                  - EMPIRE
+                  - JEDI*/
+                  episode?: ?("NEW_HOPE" | "EMPIRE" | "JEDI"),
+                |},
+                    response: {|
+
+                  /** A human character*/
+                  human: ?{|
+                    friends: ?Array<?{|
+                      name: ?string
+                    |}>
+                  |},
+                  hero: ?{|
+                    name: ?string
+                  |},
+                |}
+                |};
+            `);
+        });
+
+        it('should handle a complex input variable', () => {
+            const result = rawQueryToFlowTypes(
+                `mutation addCharacter($character: CharacterInput!) {
+                    addCharacter(character: $character) {
+                        id
+                    }
+                }`,
+                {readOnlyArray: false},
+            );
+
+            expect(result).toMatchInlineSnapshot(`
+                export type addCharacterType = {|
+                    variables: {|
+
+                  /** A character to add*/
+                  character: {|
+
+                    /** The new character's name*/
+                    name: string,
+
+                    /** The character's friends*/
+                    friends?: ?$ReadOnlyArray<string>,
+                    appearsIn?: ?$ReadOnlyArray<
+                    /** - NEW_HOPE
+                    - EMPIRE
+                    - JEDI*/
+                    "NEW_HOPE" | "EMPIRE" | "JEDI">,
+                  |}
+                |},
+                    response: {|
+                  addCharacter: ?{|
+                    id: string
+                  |}
+                |}
+                |};
+            `);
+        });
+    });
+});

package/src/__test__/jest-mock-graphql-tag.test.js

@@ -0,0 +1,51 @@
+// @flow
+import {processPragmas} from '../jest-mock-graphql-tag';
+
+const pragma = '# @autogen\n';
+const loosePragma = '# @autogen-loose\n';
+
+describe('processPragmas', () => {
+    it('should work with no pragmas', () => {
+        expect(processPragmas({}, `query X { Y }`)).toEqual({
+            strictNullability: undefined,
+            readOnlyArray: undefined,
+            scalars: undefined,
+        });
+    });
+
+    it('should reject query without required pragma', () => {
+        expect(processPragmas({pragma}, `query X { Y }`)).toEqual(null);
+    });
+
+    it('should accept query with required pragma', () => {
+        expect(
+            processPragmas(
+                {pragma},
+                `query X {
+                    # @autogen
+                    Y
+                }`,
+            ),
+        ).toEqual({
+            strictNullability: true,
+            readOnlyArray: undefined,
+            scalars: undefined,
+        });
+    });
+
+    it('should accept query with loose pragma', () => {
+        expect(
+            processPragmas(
+                {pragma, loosePragma},
+                `query X {
+                    # @autogen-loose
+                    Y
+                }`,
+            ),
+        ).toEqual({
+            strictNullability: false,
+            readOnlyArray: undefined,
+            scalars: undefined,
+        });
+    });
+});

package/src/enums.js

@@ -0,0 +1,69 @@
+// @flow
+/**
+ * Both input & output types can have enums & scalars.
+ */
+import * as babelTypes from '@babel/types';
+import {type BabelNodeFlowType} from '@babel/types';
+import type {Config} from './types';
+import {maybeAddDescriptionComment} from './utils';
+
+export const enumTypeToFlow = (
+    config: Config,
+    name: string,
+): BabelNodeFlowType => {
+    const enumConfig = config.schema.enumsByName[name];
+    let combinedDescription = enumConfig.enumValues
+        .map(
+            (n) =>
+                `- ${n.name}` +
+                (n.description
+                    ? '\n\n      ' + n.description.replace(/\n/g, '\n      ')
+                    : ''),
+        )
+        .join('\n');
+    if (enumConfig.description) {
+        combinedDescription =
+            enumConfig.description + '\n\n' + combinedDescription;
+    }
+    return maybeAddDescriptionComment(
+        combinedDescription,
+        babelTypes.unionTypeAnnotation(
+            enumConfig.enumValues.map((n) =>
+                babelTypes.stringLiteralTypeAnnotation(n.name),
+            ),
+        ),
+    );
+};
+
+export const builtinScalars: {[key: string]: string} = {
+    Boolean: 'boolean',
+    String: 'string',
+    DateTime: 'string',
+    Date: 'string',
+    ID: 'string',
+    Int: 'number',
+    Float: 'number',
+};
+
+export const scalarTypeToFlow = (
+    config: Config,
+    name: string,
+): BabelNodeFlowType => {
+    if (builtinScalars[name]) {
+        return babelTypes.genericTypeAnnotation(
+            babelTypes.identifier(builtinScalars[name]),
+        );
+    }
+    const underlyingType = config.scalars[name];
+    if (underlyingType != null) {
+        return babelTypes.genericTypeAnnotation(
+            babelTypes.identifier(underlyingType),
+        );
+    }
+    config.errors.push(
+        `Unexpected scalar '${name}'! Please add it to the "scalars" argument at the callsite of 'generateFlowTypes()'.`,
+    );
+    return babelTypes.genericTypeAnnotation(
+        babelTypes.identifier(`UNKNOWN_SCALAR["${name}"]`),
+    );
+};