Support multiple 'generate' configs, allowing projects to have different settings for different directories or files (#51)

jaredly · web-flow · commit a99fc3842be1 · 2022-06-07T16:23:00.000-05:00
## Summary: This will allow CLC to turn on experimentalEnums in a limited fashion, and will also allow us to turn on type generation for the course editor stuff, which uses a different schema. Issue: XXX-XXXX ## Test plan: jest, eslint & flow - [x] in the mobile repo, modify the config to use the new format & try out this version (https://github.com/Khan/mobile/blob/gqf-ok/react-native/tools/graphql-flow.json). See that no generated types are changed - [x] in the webapp repo, do the same, see that no generated types are changed (https://github.com/Khan/webapp/blob/gqf-multi/services/static/dev/graphql-flow/config.js). Also test out the multiple generate configs, enabling experimentalEnums for just services/static/javascript/discussion-package Author: jaredly Reviewers: nedredmond, jaredly, benchristel, kevinbarabash, jeremywiebe Required Reviewers: Approved By: nedredmond, nedredmond Checks: ✅ Lint & Test (ubuntu-latest, 16.x) Pull Request URL: #51
diff --git a/.changeset/wise-kiwis-speak.md b/.changeset/wise-kiwis-speak.md
@@ -0,0 +1,7 @@
+---
+'@khanacademy/graphql-flow': minor
+---
+
+Support multiple 'generate' configs, allowing projects to have different settings for different directories or files
+
+`config.generate` can now be an object or an array of objects, with `match` and `exclude` arrays (either a RegExp or a string that will be passed to `new RegExp()`) to fine-tune which files they apply to.
diff --git a/Readme.md b/Readme.md
@@ -4,7 +4,7 @@ This is a tool for generating flow types from graphql queries in javascript fron
 
 ## Using as a CLI tool
 
-Write a config file, following the schema defined in [src/cli/schema.json](src/cli/schema.json).
+Write a config file, following the schema defined in [src/cli/schema.json](src/cli/schema.json), either as a `.json` file, or a `.js` file that `module.exports` an object adhering to the schema.
 
 Then run from the CLI, like so:
 
@@ -14,6 +14,52 @@ $ graphql-flow path/to/config.json
 
 Files will be discovered relative to the `crawl.root`.
 
+### Multiple generate configs
+
+To customize type generation for certain directories or files, you can provide multiple
+`generate` configs as an array, using `match` and `exclude` to customize behavior.
+
+For a given file containing operations, the first `generate` config that matches that path
+(and doesn't exclude it) will be used to generate types for those operations. If a `generate`
+config doesn't have a `match` attribute, it will match all files (but might exclude some via the
+`exclude` attribute).
+
+For example:
+
+```js
+// dev/graphql-flow/config.js
+
+const options = {
+    schemaFilePath: "../../gengraphql/composed-schema.graphql",
+    regenerateCommand: "make gqlflow",
+    generatedDirectory: "__graphql-types__",
+    exclude: [
+        /_test.js$/,
+        /.fixture.js$/,
+        /\b__flowtests__\b/,
+    ],
+};
+
+module.exports = {
+    crawl: {
+        root: "../../",
+    },
+    generate: [
+        {
+            ...options,
+            schemaFilePath: "../../gengraphql/course-editor-schema.graphql",
+            match: [/\bcourse-editor-package\b/, /\bcourse-editor\b/],
+        },
+        {
+            ...options,
+            match: [/\bdiscussion-package\b/]
+            experimentalEnums: true,
+        },
+        options,
+    ],
+};
+```
+
 ## Introspecting your backend's graphql schema
 Here's how to get your backend's schema in the way that this tool expects, using the builtin 'graphql introspection query':
 
diff --git a/package.json b/package.json
@@ -7,7 +7,7 @@
     "scripts": {
         "test": "jest",
         "publish:ci": "yarn run build && yarn run copy-flow && changeset publish",
-        "build": "babel src --out-dir dist --source-maps --ignore 'src/**/*.spec.js','src/**/*.test.js'",
+        "build": "babel src -D --out-dir dist --source-maps --ignore 'src/**/*.spec.js','src/**/*.test.js'",
         "copy-flow": "node ./build-copy-source.js"
     },
     "main": "dist/index.js",
diff --git a/src/cli/__test__/config.test.js b/src/cli/__test__/config.test.js
@@ -1,23 +1,53 @@
 // @flow
 import type {Config} from '../../types';
 
-import {validateOrThrow} from '../config';
+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',
-                excludes: [
-                    '_test.js$',
+            },
+            generate: {
+                match: [/\.fixture\.js$/],
+                exclude: [
+                    '_test\\.js$',
                     '\\bcourse-editor-package\\b',
-                    '.fixture.js$',
+                    '\\.fixture\\.js$',
                     '\\b__flowtests__\\b',
                     '\\bcourse-editor\\b',
                 ],
-            },
-            generate: {
                 readOnlyArray: false,
                 regenerateCommand: 'make gqlflow',
                 scalars: {
@@ -37,6 +67,43 @@ describe('jsonschema validation', () => {
         );
     });
 
+    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(
diff --git a/src/cli/config.js b/src/cli/config.js
@@ -13,7 +13,7 @@ import {
     graphqlSync,
     type IntrospectionQuery,
 } from 'graphql';
-import type {Config} from '../types';
+import type {Config, GenerateConfig} from '../types';
 import {validate} from 'jsonschema'; // eslint-disable-line flowtype-errors/uncovered
 
 export const validateOrThrow = (value: mixed, jsonSchema: mixed) => {
@@ -28,8 +28,8 @@ export const validateOrThrow = (value: mixed, jsonSchema: mixed) => {
 };
 
 export const loadConfigFile = (configFile: string): Config => {
-    // eslint-disable-next-line flowtype-errors/uncovered
-    const data: Config = JSON.parse(fs.readFileSync(configFile, 'utf8'));
+    // $FlowIgnore // eslint-disable-next-line flowtype-errors/uncovered
+    const data: Config = require(configFile);
     // eslint-disable-next-line flowtype-errors/uncovered
     validateOrThrow(data, configSchema);
     return data;
@@ -60,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));
+    });
+};
diff --git a/src/cli/run.js b/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
 
@@ -68,10 +68,6 @@ const absConfigPath = makeAbsPath(configFilePath, process.cwd());
 
 const config = loadConfigFile(absConfigPath);
 
-const [schemaForValidation, schemaForTypeGeneration] = getSchemas(
-    makeAbsPath(config.generate.schemaFilePath, path.dirname(absConfigPath)),
-);
-
 const inputFiles = cliFiles.length
     ? cliFiles
     : findGraphqlTagReferences(
@@ -122,23 +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((filePathAndLine) => {
     const {document, raw} = resolved[filePathAndLine];
 
-    if (
-        config.crawl.excludes?.some((rx) => new RegExp(rx).test(raw.loc.path))
-    ) {
-        return; // skip
-    }
-
     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);
@@ -147,18 +157,20 @@ Object.keys(resolved).forEach((filePathAndLine) => {
     }
 
     const pragmaResult = processPragmas(
-        config.generate,
+        generateConfig,
         config.crawl,
         rawSource,
     );
     if (!pragmaResult.generate) {
         return;
     }
-    const generateConfig: GenerateConfig = {
-        ...config.generate,
-        strictNullability:
-            pragmaResult.strict ?? config.generate.strictNullability,
-    };
+    if (pragmaResult.strict != null) {
+        generateConfig.strictNullability = pragmaResult.strict;
+    }
+
+    const [schemaForValidation, schemaForTypeGeneration] = getCachedSchemas(
+        generateConfig.schemaFilePath,
+    );
 
     if (hasNonFragments) {
         /* eslint-disable flowtype-errors/uncovered */
diff --git a/src/cli/schema.json b/src/cli/schema.json
diff --git a/src/types.js b/src/types.js
