@khanacademy/graphql-flow 0.2.4 → 1.0.0

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

@@ -4,12 +4,11 @@
  * Tests for our graphql flow generation!
  */
 
-import type {DocumentNode} from 'graphql';
-
 import {getSchemas} from '../cli/config';
 import {documentToFlowTypes} from '..';
+import gql from 'graphql-tag';
 
-import type {Options} from '../types';
+import type {GenerateConfig} from '../types';
 
 // This allows us to "snapshot" a string cleanly.
 /* eslint-disable flowtype-errors/uncovered */
@@ -21,12 +20,13 @@ expect.addSnapshotSerializer({
 
 const [_, exampleSchema] = getSchemas(__dirname + '/example-schema.graphql');
 
-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 rawQueryToFlowTypes = (
+    query: string,
+    options?: $Partial<GenerateConfig>,
+): string => {
     const node = gql(query);
     return documentToFlowTypes(node, exampleSchema, {
+        schemaFilePath: '',
         scalars: {PositiveNumber: 'number'},
         ...options,
     })

package/src/__test__/processPragmas.test.js

@@ -1,63 +1,76 @@
 // @flow
+import type {CrawlConfig, GenerateConfig} from '../types';
+
 import {processPragmas} from '../generateTypeFiles';
 
 const pragma = '# @autogen\n';
 const loosePragma = '# @autogen-loose\n';
 
+const baseGenerate: GenerateConfig = {schemaFilePath: ''};
+const baseCrawl: CrawlConfig = {root: ''};
+
 describe('processPragmas', () => {
     it('should work with no pragmas', () => {
-        expect(processPragmas({}, `query X { Y }`)).toEqual({
-            strictNullability: undefined,
-            readOnlyArray: undefined,
-            scalars: undefined,
+        expect(
+            processPragmas(baseGenerate, baseCrawl, `query X { Y }`),
+        ).toEqual({
+            generate: true,
+            strict: undefined,
         });
     });
 
     it('should reject query without required pragma', () => {
-        expect(processPragmas({pragma}, `query X { Y }`)).toEqual(null);
+        expect(
+            processPragmas(
+                baseGenerate,
+                {...baseCrawl, pragma},
+                `query X { Y }`,
+            ),
+        ).toEqual({generate: false});
     });
 
     it('should accept query with required pragma', () => {
         expect(
             processPragmas(
-                {pragma},
+                baseGenerate,
+                {...baseCrawl, pragma},
                 `query X {
                     # @autogen
                     Y
                 }`,
             ),
         ).toEqual({
-            strictNullability: true,
-            readOnlyArray: undefined,
-            scalars: undefined,
+            strict: true,
+            generate: true,
         });
     });
 
     it('should accept query with loose pragma', () => {
         expect(
             processPragmas(
-                {pragma, loosePragma},
+                baseGenerate,
+                {...baseCrawl, pragma, loosePragma},
                 `query X {
                     # @autogen-loose
                     Y
                 }`,
             ),
         ).toEqual({
-            strictNullability: false,
-            readOnlyArray: undefined,
-            scalars: undefined,
+            strict: false,
+            generate: true,
         });
     });
 
     it('should reject query with ignore pragma', () => {
         expect(
             processPragmas(
-                {ignorePragma: '# @ignore\n'},
+                baseGenerate,
+                {...baseCrawl, ignorePragma: '# @ignore\n'},
                 `query X {
                     # @ignore
                     Y
                 }`,
             ),
-        ).toEqual(null);
+        ).toEqual({generate: false});
     });
 });

package/src/cli/__test__/config.test.js

@@ -0,0 +1,120 @@
+// @flow
+import type {Config} from '../../types';
+
+import {findApplicableConfig, validateOrThrow} from '../config';
+import configSchema from '../schema.json'; // eslint-disable-line flowtype-errors/uncovered
+
+describe('findApplicableConfig', () => {
+    it('should work with one that matches', () => {
+        const config = {
+            schemaFilePath: 'ok.graphql',
+        };
+        expect(findApplicableConfig('/hello', config)).toBe(config);
+    });
+
+    it('should be falsy if nothing matches', () => {
+        const config = {
+            schemaFilePath: 'ok.graphql',
+            exclude: [/hello$/],
+        };
+        expect(findApplicableConfig('/hello', config)).toBeUndefined();
+    });
+
+    it('should match & exclude with multiple configs', () => {
+        const configs = [
+            {schemaFilePath: 'one', match: [/\.jsx$/], exclude: [/^test/]},
+            {schemaFilePath: 'two', exclude: [/^hello/]},
+            {schemaFilePath: 'three'},
+        ];
+        expect(findApplicableConfig('hello.js', configs)).toBe(configs[2]);
+        expect(findApplicableConfig('goodbye.js', configs)).toBe(configs[1]);
+        expect(findApplicableConfig('hello.jsx', configs)).toBe(configs[0]);
+        expect(findApplicableConfig('test.jsx', configs)).toBe(configs[1]);
+    });
+});
+
+describe('jsonschema validation', () => {
+    it('should accept valid schema', () => {
+        const config: Config = {
+            crawl: {
+                root: '/here/we/crawl',
+            },
+            generate: {
+                match: [/\.fixture\.js$/],
+                exclude: [
+                    '_test\\.js$',
+                    '\\bcourse-editor-package\\b',
+                    '\\.fixture\\.js$',
+                    '\\b__flowtests__\\b',
+                    '\\bcourse-editor\\b',
+                ],
+                readOnlyArray: false,
+                regenerateCommand: 'make gqlflow',
+                scalars: {
+                    JSONString: 'string',
+                    KALocale: 'string',
+                    NaiveDateTime: 'string',
+                },
+                splitTypes: true,
+                generatedDirectory: '__graphql-types__',
+                exportAllObjectTypes: true,
+                schemaFilePath: './composed_schema.graphql',
+            },
+        };
+        validateOrThrow(
+            config,
+            configSchema, // eslint-disable-line flowtype-errors/uncovered
+        );
+    });
+
+    it('should accept a schema with multiple generate configs', () => {
+        const generate = {
+            match: [/\.fixture\.js$/],
+            exclude: [
+                '_test\\.js$',
+                '\\bcourse-editor-package\\b',
+                '\\.fixture\\.js$',
+                '\\b__flowtests__\\b',
+                '\\bcourse-editor\\b',
+            ],
+            readOnlyArray: false,
+            regenerateCommand: 'make gqlflow',
+            scalars: {
+                JSONString: 'string',
+                KALocale: 'string',
+                NaiveDateTime: 'string',
+            },
+            splitTypes: true,
+            generatedDirectory: '__graphql-types__',
+            exportAllObjectTypes: true,
+            schemaFilePath: './composed_schema.graphql',
+        };
+        const config: Config = {
+            crawl: {
+                root: '/here/we/crawl',
+            },
+            generate: [
+                {...generate, match: [/^static/], exportAllObjectTypes: false},
+                generate,
+            ],
+        };
+        validateOrThrow(
+            config,
+            configSchema, // eslint-disable-line flowtype-errors/uncovered
+        );
+    });
+
+    it('should reject invalid schema', () => {
+        expect(() =>
+            validateOrThrow(
+                {schemaFilePath: 10, options: {extraOption: 'hello'}},
+                configSchema, // eslint-disable-line flowtype-errors/uncovered
+            ),
+        ).toThrowErrorMatchingInlineSnapshot(`
+            "instance is not allowed to have the additional property \\"schemaFilePath\\"
+            instance is not allowed to have the additional property \\"options\\"
+            instance requires property \\"crawl\\"
+            instance requires property \\"generate\\""
+        `);
+    });
+});

package/src/cli/config.js

@@ -1,9 +1,9 @@
 // @flow
-import type {ExternalOptions} from '../generateTypeFiles';
 import type {Schema} from '../types';
 import type {GraphQLSchema} from 'graphql/type/schema';
 
 import {schemaFromIntrospectionData} from '../schemaFromIntrospectionData';
+import configSchema from './schema.json'; // eslint-disable-line flowtype-errors/uncovered
 
 import fs from 'fs';
 import {
@@ -13,77 +13,26 @@ import {
     graphqlSync,
     type IntrospectionQuery,
 } from 'graphql';
-import path from 'path';
+import type {Config, GenerateConfig} from '../types';
+import {validate} from 'jsonschema'; // eslint-disable-line flowtype-errors/uncovered
 
-export type CliConfig = {
-    excludes: Array<RegExp>,
-    schemaFilePath: string,
-    dumpOperations?: string,
-    options: ExternalOptions,
-};
-
-/**
- * This is the json-compatible form of the config
- * object.
- */
-type JSONConfig = {
-    excludes?: Array<string>,
-    schemaFilePath: string,
-    options?: ExternalOptions,
-    dumpOperations?: string,
+export const validateOrThrow = (value: mixed, jsonSchema: mixed) => {
+    /* eslint-disable flowtype-errors/uncovered */
+    const result = validate(value, jsonSchema);
+    if (!result.valid) {
+        throw new Error(
+            result.errors.map((error) => error.toString()).join('\n'),
+        );
+    }
+    /* eslint-enable flowtype-errors/uncovered */
 };
 
-export const loadConfigFile = (configFile: string): CliConfig => {
+export const loadConfigFile = (configFile: string): Config => {
+    // $FlowIgnore // eslint-disable-next-line flowtype-errors/uncovered
+    const data: Config = require(configFile);
     // eslint-disable-next-line flowtype-errors/uncovered
-    const data: JSONConfig = JSON.parse(fs.readFileSync(configFile, 'utf8'));
-    const toplevelKeys = [
-        'excludes',
-        'schemaFilePath',
-        'options',
-        'dumpOperations',
-    ];
-    Object.keys(data).forEach((k) => {
-        if (!toplevelKeys.includes(k)) {
-            throw new Error(
-                `Invalid attribute in config file ${configFile}: ${k}. Allowed attributes: ${toplevelKeys.join(
-                    ', ',
-                )}`,
-            );
-        }
-    });
-    if (data.options) {
-        const externalOptionsKeys = [
-            'pragma',
-            'loosePragma',
-            'ignorePragma',
-            'scalars',
-            'strictNullability',
-            'regenerateCommand',
-            'readOnlyArray',
-            'splitTypes',
-            'generatedDirectory',
-            'exportAllObjectTypes',
-            'typeFileName',
-        ];
-        Object.keys(data.options).forEach((k) => {
-            if (!externalOptionsKeys.includes(k)) {
-                throw new Error(
-                    `Invalid option in config file ${configFile}: ${k}. Allowed options: ${externalOptionsKeys.join(
-                        ', ',
-                    )}`,
-                );
-            }
-        });
-    }
-    return {
-        options: data.options ?? {},
-        excludes: data.excludes?.map((string) => new RegExp(string)) ?? [],
-        schemaFilePath: path.join(
-            path.dirname(configFile),
-            data.schemaFilePath,
-        ),
-        dumpOperations: data.dumpOperations,
-    };
+    validateOrThrow(data, configSchema);
+    return data;
 };
 
 /**
@@ -111,3 +60,26 @@ export const getSchemas = (schemaFilePath: string): [GraphQLSchema, Schema] => {
         return [schemaForValidation, schemaForTypeGeneration];
     }
 };
+
+/**
+ * Find the first item of the `config.generate` array where both:
+ * - no item of `exclude` matches
+ * - at least one item of `match` matches
+ */
+export const findApplicableConfig = (
+    path: string,
+    configs: Array<GenerateConfig> | GenerateConfig,
+): ?GenerateConfig => {
+    if (!Array.isArray(configs)) {
+        configs = [configs];
+    }
+    return configs.find((config) => {
+        if (config.exclude?.some((exclude) => new RegExp(exclude).test(path))) {
+            return false;
+        }
+        if (!config.match) {
+            return true;
+        }
+        return config.match.some((matcher) => new RegExp(matcher).test(path));
+    });
+};

package/src/cli/run.js

@@ -4,7 +4,7 @@
 import {generateTypeFiles, processPragmas} from '../generateTypeFiles';
 import {processFiles} from '../parser/parse';
 import {resolveDocuments} from '../parser/resolve';
-import {getSchemas, loadConfigFile} from './config';
+import {findApplicableConfig, getSchemas, loadConfigFile} from './config';
 
 import {addTypenameToDocument} from 'apollo-utilities'; // eslint-disable-line flowtype-errors/uncovered
 
@@ -15,10 +15,11 @@ import {print} from 'graphql/language/printer';
 import {validate} from 'graphql/validation';
 import path from 'path';
 import {dirname} from 'path';
+import type {GenerateConfig} from '../types';
 
 /**
  * This CLI tool executes the following steps:
- * 1) process options
+ * 1) parse & validate config file
  * 2) crawl files to find all operations and fragments, with
  *   tagged template literals and expressions.
  * 3) resolve the found operations, passing the literals and
@@ -43,13 +44,13 @@ const findGraphqlTagReferences = (root: string): Array<string> => {
         .map((relative) => path.join(root, relative));
 };
 
-const [_, __, configFile, ...cliFiles] = process.argv;
+const [_, __, configFilePath, ...cliFiles] = process.argv;
 
 if (
-    configFile === '-h' ||
-    configFile === '--help' ||
-    configFile === 'help' ||
-    !configFile
+    configFilePath === '-h' ||
+    configFilePath === '--help' ||
+    configFilePath === 'help' ||
+    !configFilePath
 ) {
     console.log(`graphql-flow
 
@@ -57,15 +58,21 @@ Usage: graphql-flow [configFile.json] [filesToCrawl...]`);
     process.exit(1); // eslint-disable-line flowtype-errors/uncovered
 }
 
-const config = loadConfigFile(configFile);
+const makeAbsPath = (maybeRelativePath: string, basePath: string) => {
+    return path.isAbsolute(maybeRelativePath)
+        ? maybeRelativePath
+        : path.join(basePath, maybeRelativePath);
+};
+
+const absConfigPath = makeAbsPath(configFilePath, process.cwd());
 
-const [schemaForValidation, schemaForTypeGeneration] = getSchemas(
-    config.schemaFilePath,
-);
+const config = loadConfigFile(absConfigPath);
 
 const inputFiles = cliFiles.length
     ? cliFiles
-    : findGraphqlTagReferences(process.cwd());
+    : findGraphqlTagReferences(
+          makeAbsPath(config.crawl.root, path.dirname(absConfigPath)),
+      );
 
 /** Step (2) */
 
@@ -111,19 +118,37 @@ console.log(Object.keys(resolved).length, 'resolved queries');
 
 /** Step (4) */
 
+const schemaCache = {};
+const getCachedSchemas = (schemaFilePath: string) => {
+    if (!schemaCache[schemaFilePath]) {
+        schemaCache[schemaFilePath] = getSchemas(
+            makeAbsPath(schemaFilePath, path.dirname(absConfigPath)),
+        );
+    }
+
+    return schemaCache[schemaFilePath];
+};
+
 let validationFailures: number = 0;
 const printedOperations: Array<string> = [];
 
-Object.keys(resolved).forEach((k) => {
-    const {document, raw} = resolved[k];
-    if (config.excludes.some((rx) => rx.test(raw.loc.path))) {
-        return; // skip
-    }
+Object.keys(resolved).forEach((filePathAndLine) => {
+    const {document, raw} = resolved[filePathAndLine];
+
     const hasNonFragments = document.definitions.some(
         ({kind}) => kind !== 'FragmentDefinition',
     );
     const rawSource: string = raw.literals[0];
 
+    const generateConfig = findApplicableConfig(
+        // strip off the trailing line number, e.g. `:23`
+        filePathAndLine.split(':')[0],
+        config.generate,
+    );
+    if (!generateConfig) {
+        return; // no generate config matches, bail
+    }
+
     // eslint-disable-next-line flowtype-errors/uncovered
     const withTypeNames: DocumentNode = addTypenameToDocument(document);
     const printed = print(withTypeNames);
@@ -131,10 +156,21 @@ Object.keys(resolved).forEach((k) => {
         printedOperations.push(printed);
     }
 
-    const processedOptions = processPragmas(config.options, rawSource);
-    if (!processedOptions) {
+    const pragmaResult = processPragmas(
+        generateConfig,
+        config.crawl,
+        rawSource,
+    );
+    if (!pragmaResult.generate) {
         return;
     }
+    if (pragmaResult.strict != null) {
+        generateConfig.strictNullability = pragmaResult.strict;
+    }
+
+    const [schemaForValidation, schemaForTypeGeneration] = getCachedSchemas(
+        generateConfig.schemaFilePath,
+    );
 
     if (hasNonFragments) {
         /* eslint-disable flowtype-errors/uncovered */
@@ -158,7 +194,7 @@ Object.keys(resolved).forEach((k) => {
             raw.loc.path,
             schemaForTypeGeneration,
             withTypeNames,
-            processedOptions,
+            generateConfig,
         );
         // eslint-disable-next-line flowtype-errors/uncovered
     } catch (err) {
@@ -178,8 +214,8 @@ if (validationFailures) {
     process.exit(1);
 }
 
-if (config.dumpOperations) {
-    const dumpOperations = config.dumpOperations;
+if (config.crawl.dumpOperations) {
+    const dumpOperations = config.crawl.dumpOperations;
     const parent = dirname(dumpOperations);
     mkdirSync(parent, {recursive: true});
     writeFileSync(

package/src/cli/schema.json

@@ -0,0 +1,91 @@
+{
+    "$schema":"http://json-schema.org/draft-07/schema",
+    "type": "object",
+    "additionalProperties": false,
+    "definitions": {
+        "GenerateConfig": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+                "schemaFilePath": {
+                    "type": "string"
+                },
+                "match": {
+                    "type": "array",
+                    "items": {
+                        "oneOf": [
+                            { "type": "object" },
+                            { "type": "string" }
+                        ]
+                    }
+                },
+                "exclude": {
+                    "type": "array",
+                    "items": {
+                        "oneOf": [
+                            { "type": "object" },
+                            { "type": "string" }
+                        ]
+                    }
+                },
+                "scalars": {
+                    "type": "object"
+                },
+                "strictNullability": {
+                    "type": "boolean"
+                },
+                "regenerateCommand": {
+                    "type": "string"
+                },
+                "readOnlyArray": {
+                    "type": "boolean"
+                },
+                "splitTypes": {
+                    "type": "boolean"
+                },
+                "generatedDirectory": {
+                    "type": "string"
+                },
+                "exportAllObjectTypes": {
+                    "type": "boolean"
+                },
+                "typeFileName": {
+                    "type": "string"
+                },
+                "experimentalEnums": {
+                    "type": "boolean"
+                }
+            },
+            "required": [
+                "schemaFilePath"
+            ]
+        }
+    },
+    "properties": {
+        "crawl": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+                "root": {"type": "string"},
+                "pragma": {
+                    "type": "string"
+                },
+                "loosePragma": {
+                    "type": "string"
+                },
+                "ignorePragma": {
+                    "type": "string"
+                },
+                "dumpOperations": {
+                    "type": "string"
+                }
+            },
+            "required": [ "root" ]
+        },
+        "generate": {"oneOf": [
+            {"$ref": "#/definitions/GenerateConfig"},
+            {"type": "array", "items": {"$ref": "#/definitions/GenerateConfig"}}
+        ]}
+    },
+    "required": [ "crawl", "generate" ]
+}