@khanacademy/graphql-flow 0.2.4 → 1.0.0

package/dist/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/dist/cli/config.js

@@ -3,45 +3,42 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.loadConfigFile = exports.getSchemas = void 0;
+exports.validateOrThrow = exports.loadConfigFile = exports.getSchemas = exports.findApplicableConfig = void 0;
 
 var _schemaFromIntrospectionData = require("../schemaFromIntrospectionData");
 
+var _schema = _interopRequireDefault(require("./schema.json"));
+
 var _fs = _interopRequireDefault(require("fs"));
 
 var _graphql = require("graphql");
 
-var _path = _interopRequireDefault(require("path"));
+var _jsonschema = require("jsonschema");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-const loadConfigFile = configFile => {
-  var _data$options, _data$excludes$map, _data$excludes;
-
-  // eslint-disable-next-line flowtype-errors/uncovered
-  const data = JSON.parse(_fs.default.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(', ')}`);
-    }
-  });
+// eslint-disable-line flowtype-errors/uncovered
+// eslint-disable-line flowtype-errors/uncovered
+const validateOrThrow = (value, jsonSchema) => {
+  /* eslint-disable flowtype-errors/uncovered */
+  const result = (0, _jsonschema.validate)(value, jsonSchema);
 
-  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(', ')}`);
-      }
-    });
+  if (!result.valid) {
+    throw new Error(result.errors.map(error => error.toString()).join('\n'));
   }
+  /* eslint-enable flowtype-errors/uncovered */
+
+};
 
-  return {
-    options: (_data$options = data.options) !== null && _data$options !== void 0 ? _data$options : {},
-    excludes: (_data$excludes$map = (_data$excludes = data.excludes) === null || _data$excludes === void 0 ? void 0 : _data$excludes.map(string => new RegExp(string))) !== null && _data$excludes$map !== void 0 ? _data$excludes$map : [],
-    schemaFilePath: _path.default.join(_path.default.dirname(configFile), data.schemaFilePath),
-    dumpOperations: data.dumpOperations
-  };
+exports.validateOrThrow = validateOrThrow;
+
+const loadConfigFile = configFile => {
+  // $FlowIgnore // eslint-disable-next-line flowtype-errors/uncovered
+  const data = require(configFile); // eslint-disable-next-line flowtype-errors/uncovered
+
+
+  validateOrThrow(data, _schema.default);
+  return data;
 };
 /**
  * Loads a .json 'introspection query response', or a .graphql schema definition.
@@ -69,6 +66,34 @@ const getSchemas = schemaFilePath => {
     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
+ */
+
 
 exports.getSchemas = getSchemas;
+
+const findApplicableConfig = (path, configs) => {
+  if (!Array.isArray(configs)) {
+    configs = [configs];
+  }
+
+  return configs.find(config => {
+    var _config$exclude;
+
+    if ((_config$exclude = config.exclude) !== null && _config$exclude !== void 0 && _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));
+  });
+};
+
+exports.findApplicableConfig = findApplicableConfig;
 //# sourceMappingURL=config.js.map

package/dist/cli/config.js.flow

@@ -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/dist/cli/config.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/cli/config.js"],"names":["loadConfigFile","configFile","data","JSON","parse","fs","readFileSync","toplevelKeys","Object","keys","forEach","k","includes","Error","join","options","externalOptionsKeys","excludes","map","string","RegExp","schemaFilePath","path","dirname","dumpOperations","getSchemas","raw","endsWith","schemaForValidation","queryResponse","descriptions","schemaForTypeGeneration","introspectionData"],"mappings":";;;;;;;AAKA;;AAEA;;AACA;;AAOA;;;;AAoBO,MAAMA,cAAc,GAAIC,UAAD,IAAmC;AAAA;;AAC7D;AACA,QAAMC,IAAgB,GAAGC,IAAI,CAACC,KAAL,CAAWC,YAAGC,YAAH,CAAgBL,UAAhB,EAA4B,MAA5B,CAAX,CAAzB;AACA,QAAMM,YAAY,GAAG,CACjB,UADiB,EAEjB,gBAFiB,EAGjB,SAHiB,EAIjB,gBAJiB,CAArB;AAMAC,EAAAA,MAAM,CAACC,IAAP,CAAYP,IAAZ,EAAkBQ,OAAlB,CAA2BC,CAAD,IAAO;AAC7B,QAAI,CAACJ,YAAY,CAACK,QAAb,CAAsBD,CAAtB,CAAL,EAA+B;AAC3B,YAAM,IAAIE,KAAJ,CACD,oCAAmCZ,UAAW,KAAIU,CAAE,yBAAwBJ,YAAY,CAACO,IAAb,CACzE,IADyE,CAE3E,EAHA,CAAN;AAKH;AACJ,GARD;;AASA,MAAIZ,IAAI,CAACa,OAAT,EAAkB;AACd,UAAMC,mBAAmB,GAAG,CACxB,QADwB,EAExB,aAFwB,EAGxB,cAHwB,EAIxB,SAJwB,EAKxB,mBALwB,EAMxB,mBANwB,EAOxB,eAPwB,EAQxB,YARwB,EASxB,oBATwB,EAUxB,sBAVwB,EAWxB,cAXwB,CAA5B;AAaAR,IAAAA,MAAM,CAACC,IAAP,CAAYP,IAAI,CAACa,OAAjB,EAA0BL,OAA1B,CAAmCC,CAAD,IAAO;AACrC,UAAI,CAACK,mBAAmB,CAACJ,QAApB,CAA6BD,CAA7B,CAAL,EAAsC;AAClC,cAAM,IAAIE,KAAJ,CACD,iCAAgCZ,UAAW,KAAIU,CAAE,sBAAqBK,mBAAmB,CAACF,IAApB,CACnE,IADmE,CAErE,EAHA,CAAN;AAKH;AACJ,KARD;AASH;;AACD,SAAO;AACHC,IAAAA,OAAO,mBAAEb,IAAI,CAACa,OAAP,yDAAkB,EADtB;AAEHE,IAAAA,QAAQ,0CAAEf,IAAI,CAACe,QAAP,mDAAE,eAAeC,GAAf,CAAoBC,MAAD,IAAY,IAAIC,MAAJ,CAAWD,MAAX,CAA/B,CAAF,mEAAwD,EAF7D;AAGHE,IAAAA,cAAc,EAAEC,cAAKR,IAAL,CACZQ,cAAKC,OAAL,CAAatB,UAAb,CADY,EAEZC,IAAI,CAACmB,cAFO,CAHb;AAOHG,IAAAA,cAAc,EAAEtB,IAAI,CAACsB;AAPlB,GAAP;AASH,CAnDM;AAqDP;AACA;AACA;;;;;AACO,MAAMC,UAAU,GAAIJ,cAAD,IAAqD;AAC3E,QAAMK,GAAG,GAAGrB,YAAGC,YAAH,CAAgBe,cAAhB,EAAgC,MAAhC,CAAZ;;AACA,MAAIA,cAAc,CAACM,QAAf,CAAwB,UAAxB,CAAJ,EAAyC;AACrC,UAAMC,mBAAmB,GAAG,0BAAYF,GAAZ,CAA5B;AACA,UAAMG,aAAa,GAAG,0BAClBD,mBADkB,EAElB,oCAAsB;AAACE,MAAAA,YAAY,EAAE;AAAf,KAAtB,CAFkB,CAAtB;AAIA,UAAMC,uBAAuB,GAAG,+DAC5B;AACEF,IAAAA,aAAa,CAAC3B,IAFY,CAAhC;AAIA,WAAO,CAAC0B,mBAAD,EAAsBG,uBAAtB,CAAP;AACH,GAXD,MAWO;AACH;AACA,UAAMC,iBAAqC,GAAG7B,IAAI,CAACC,KAAL,CAAWsB,GAAX,CAA9C;AACA,UAAME,mBAAmB,GAAG,gCAAkBI,iBAAlB,CAA5B;AACA,UAAMD,uBAAuB,GACzB,8DAA4BC,iBAA5B,CADJ;AAEA,WAAO,CAACJ,mBAAD,EAAsBG,uBAAtB,CAAP;AACH;AACJ,CArBM","sourcesContent":["// @flow\nimport type {ExternalOptions} from '../generateTypeFiles';\nimport type {Schema} from '../types';\nimport type {GraphQLSchema} from 'graphql/type/schema';\n\nimport {schemaFromIntrospectionData} from '../schemaFromIntrospectionData';\n\nimport fs from 'fs';\nimport {\n    buildClientSchema,\n    buildSchema,\n    getIntrospectionQuery,\n    graphqlSync,\n    type IntrospectionQuery,\n} from 'graphql';\nimport path from 'path';\n\nexport type CliConfig = {\n    excludes: Array<RegExp>,\n    schemaFilePath: string,\n    dumpOperations?: string,\n    options: ExternalOptions,\n};\n\n/**\n * This is the json-compatible form of the config\n * object.\n */\ntype JSONConfig = {\n    excludes?: Array<string>,\n    schemaFilePath: string,\n    options?: ExternalOptions,\n    dumpOperations?: string,\n};\n\nexport const loadConfigFile = (configFile: string): CliConfig => {\n    // eslint-disable-next-line flowtype-errors/uncovered\n    const data: JSONConfig = JSON.parse(fs.readFileSync(configFile, 'utf8'));\n    const toplevelKeys = [\n        'excludes',\n        'schemaFilePath',\n        'options',\n        'dumpOperations',\n    ];\n    Object.keys(data).forEach((k) => {\n        if (!toplevelKeys.includes(k)) {\n            throw new Error(\n                `Invalid attribute in config file ${configFile}: ${k}. Allowed attributes: ${toplevelKeys.join(\n                    ', ',\n                )}`,\n            );\n        }\n    });\n    if (data.options) {\n        const externalOptionsKeys = [\n            'pragma',\n            'loosePragma',\n            'ignorePragma',\n            'scalars',\n            'strictNullability',\n            'regenerateCommand',\n            'readOnlyArray',\n            'splitTypes',\n            'generatedDirectory',\n            'exportAllObjectTypes',\n            'typeFileName',\n        ];\n        Object.keys(data.options).forEach((k) => {\n            if (!externalOptionsKeys.includes(k)) {\n                throw new Error(\n                    `Invalid option in config file ${configFile}: ${k}. Allowed options: ${externalOptionsKeys.join(\n                        ', ',\n                    )}`,\n                );\n            }\n        });\n    }\n    return {\n        options: data.options ?? {},\n        excludes: data.excludes?.map((string) => new RegExp(string)) ?? [],\n        schemaFilePath: path.join(\n            path.dirname(configFile),\n            data.schemaFilePath,\n        ),\n        dumpOperations: data.dumpOperations,\n    };\n};\n\n/**\n * Loads a .json 'introspection query response', or a .graphql schema definition.\n */\nexport const getSchemas = (schemaFilePath: string): [GraphQLSchema, Schema] => {\n    const raw = fs.readFileSync(schemaFilePath, 'utf8');\n    if (schemaFilePath.endsWith('.graphql')) {\n        const schemaForValidation = buildSchema(raw);\n        const queryResponse = graphqlSync(\n            schemaForValidation,\n            getIntrospectionQuery({descriptions: true}),\n        );\n        const schemaForTypeGeneration = schemaFromIntrospectionData(\n            // eslint-disable-next-line flowtype-errors/uncovered\n            ((queryResponse.data: any): IntrospectionQuery),\n        );\n        return [schemaForValidation, schemaForTypeGeneration];\n    } else {\n        // eslint-disable-next-line flowtype-errors/uncovered\n        const introspectionData: IntrospectionQuery = JSON.parse(raw);\n        const schemaForValidation = buildClientSchema(introspectionData);\n        const schemaForTypeGeneration =\n            schemaFromIntrospectionData(introspectionData);\n        return [schemaForValidation, schemaForTypeGeneration];\n    }\n};\n"],"file":"config.js"}
+{"version":3,"sources":["../../src/cli/config.js"],"names":["validateOrThrow","value","jsonSchema","result","valid","Error","errors","map","error","toString","join","loadConfigFile","configFile","data","require","configSchema","getSchemas","schemaFilePath","raw","fs","readFileSync","endsWith","schemaForValidation","queryResponse","descriptions","schemaForTypeGeneration","introspectionData","JSON","parse","findApplicableConfig","path","configs","Array","isArray","find","config","exclude","some","RegExp","test","match","matcher"],"mappings":";;;;;;;AAIA;;AACA;;AAEA;;AACA;;AAQA;;;;AAX0C;AAWL;AAE9B,MAAMA,eAAe,GAAG,CAACC,KAAD,EAAeC,UAAf,KAAqC;AAChE;AACA,QAAMC,MAAM,GAAG,0BAASF,KAAT,EAAgBC,UAAhB,CAAf;;AACA,MAAI,CAACC,MAAM,CAACC,KAAZ,EAAmB;AACf,UAAM,IAAIC,KAAJ,CACFF,MAAM,CAACG,MAAP,CAAcC,GAAd,CAAmBC,KAAD,IAAWA,KAAK,CAACC,QAAN,EAA7B,EAA+CC,IAA/C,CAAoD,IAApD,CADE,CAAN;AAGH;AACD;;AACH,CATM;;;;AAWA,MAAMC,cAAc,GAAIC,UAAD,IAAgC;AAC1D;AACA,QAAMC,IAAY,GAAGC,OAAO,CAACF,UAAD,CAA5B,CAF0D,CAG1D;;;AACAZ,EAAAA,eAAe,CAACa,IAAD,EAAOE,eAAP,CAAf;AACA,SAAOF,IAAP;AACH,CANM;AAQP;AACA;AACA;;;;;AACO,MAAMG,UAAU,GAAIC,cAAD,IAAqD;AAC3E,QAAMC,GAAG,GAAGC,YAAGC,YAAH,CAAgBH,cAAhB,EAAgC,MAAhC,CAAZ;;AACA,MAAIA,cAAc,CAACI,QAAf,CAAwB,UAAxB,CAAJ,EAAyC;AACrC,UAAMC,mBAAmB,GAAG,0BAAYJ,GAAZ,CAA5B;AACA,UAAMK,aAAa,GAAG,0BAClBD,mBADkB,EAElB,oCAAsB;AAACE,MAAAA,YAAY,EAAE;AAAf,KAAtB,CAFkB,CAAtB;AAIA,UAAMC,uBAAuB,GAAG,+DAC5B;AACEF,IAAAA,aAAa,CAACV,IAFY,CAAhC;AAIA,WAAO,CAACS,mBAAD,EAAsBG,uBAAtB,CAAP;AACH,GAXD,MAWO;AACH;AACA,UAAMC,iBAAqC,GAAGC,IAAI,CAACC,KAAL,CAAWV,GAAX,CAA9C;AACA,UAAMI,mBAAmB,GAAG,gCAAkBI,iBAAlB,CAA5B;AACA,UAAMD,uBAAuB,GACzB,8DAA4BC,iBAA5B,CADJ;AAEA,WAAO,CAACJ,mBAAD,EAAsBG,uBAAtB,CAAP;AACH;AACJ,CArBM;AAuBP;AACA;AACA;AACA;AACA;;;;;AACO,MAAMI,oBAAoB,GAAG,CAChCC,IADgC,EAEhCC,OAFgC,KAGd;AAClB,MAAI,CAACC,KAAK,CAACC,OAAN,CAAcF,OAAd,CAAL,EAA6B;AACzBA,IAAAA,OAAO,GAAG,CAACA,OAAD,CAAV;AACH;;AACD,SAAOA,OAAO,CAACG,IAAR,CAAcC,MAAD,IAAY;AAAA;;AAC5B,2BAAIA,MAAM,CAACC,OAAX,4CAAI,gBAAgBC,IAAhB,CAAsBD,OAAD,IAAa,IAAIE,MAAJ,CAAWF,OAAX,EAAoBG,IAApB,CAAyBT,IAAzB,CAAlC,CAAJ,EAAuE;AACnE,aAAO,KAAP;AACH;;AACD,QAAI,CAACK,MAAM,CAACK,KAAZ,EAAmB;AACf,aAAO,IAAP;AACH;;AACD,WAAOL,MAAM,CAACK,KAAP,CAAaH,IAAb,CAAmBI,OAAD,IAAa,IAAIH,MAAJ,CAAWG,OAAX,EAAoBF,IAApB,CAAyBT,IAAzB,CAA/B,CAAP;AACH,GARM,CAAP;AASH,CAhBM","sourcesContent":["// @flow\nimport type {Schema} from '../types';\nimport type {GraphQLSchema} from 'graphql/type/schema';\n\nimport {schemaFromIntrospectionData} from '../schemaFromIntrospectionData';\nimport configSchema from './schema.json'; // eslint-disable-line flowtype-errors/uncovered\n\nimport fs from 'fs';\nimport {\n    buildClientSchema,\n    buildSchema,\n    getIntrospectionQuery,\n    graphqlSync,\n    type IntrospectionQuery,\n} from 'graphql';\nimport type {Config, GenerateConfig} from '../types';\nimport {validate} from 'jsonschema'; // eslint-disable-line flowtype-errors/uncovered\n\nexport const validateOrThrow = (value: mixed, jsonSchema: mixed) => {\n    /* eslint-disable flowtype-errors/uncovered */\n    const result = validate(value, jsonSchema);\n    if (!result.valid) {\n        throw new Error(\n            result.errors.map((error) => error.toString()).join('\\n'),\n        );\n    }\n    /* eslint-enable flowtype-errors/uncovered */\n};\n\nexport const loadConfigFile = (configFile: string): Config => {\n    // $FlowIgnore // eslint-disable-next-line flowtype-errors/uncovered\n    const data: Config = require(configFile);\n    // eslint-disable-next-line flowtype-errors/uncovered\n    validateOrThrow(data, configSchema);\n    return data;\n};\n\n/**\n * Loads a .json 'introspection query response', or a .graphql schema definition.\n */\nexport const getSchemas = (schemaFilePath: string): [GraphQLSchema, Schema] => {\n    const raw = fs.readFileSync(schemaFilePath, 'utf8');\n    if (schemaFilePath.endsWith('.graphql')) {\n        const schemaForValidation = buildSchema(raw);\n        const queryResponse = graphqlSync(\n            schemaForValidation,\n            getIntrospectionQuery({descriptions: true}),\n        );\n        const schemaForTypeGeneration = schemaFromIntrospectionData(\n            // eslint-disable-next-line flowtype-errors/uncovered\n            ((queryResponse.data: any): IntrospectionQuery),\n        );\n        return [schemaForValidation, schemaForTypeGeneration];\n    } else {\n        // eslint-disable-next-line flowtype-errors/uncovered\n        const introspectionData: IntrospectionQuery = JSON.parse(raw);\n        const schemaForValidation = buildClientSchema(introspectionData);\n        const schemaForTypeGeneration =\n            schemaFromIntrospectionData(introspectionData);\n        return [schemaForValidation, schemaForTypeGeneration];\n    }\n};\n\n/**\n * Find the first item of the `config.generate` array where both:\n * - no item of `exclude` matches\n * - at least one item of `match` matches\n */\nexport const findApplicableConfig = (\n    path: string,\n    configs: Array<GenerateConfig> | GenerateConfig,\n): ?GenerateConfig => {\n    if (!Array.isArray(configs)) {\n        configs = [configs];\n    }\n    return configs.find((config) => {\n        if (config.exclude?.some((exclude) => new RegExp(exclude).test(path))) {\n            return false;\n        }\n        if (!config.match) {\n            return true;\n        }\n        return config.match.some((matcher) => new RegExp(matcher).test(path));\n    });\n};\n"],"file":"config.js"}

package/dist/cli/run.js

@@ -31,7 +31,7 @@ function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj &&
 
 /**
  * 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
@@ -49,18 +49,22 @@ const findGraphqlTagReferences = root => {
   return response.trim().split('\n').map(relative => _path.default.join(root, relative));
 };
 
-const [_, __, configFile, ...cliFiles] = process.argv;
+const [_, __, configFilePath, ...cliFiles] = process.argv;
 
-if (configFile === '-h' || configFile === '--help' || configFile === 'help' || !configFile) {
+if (configFilePath === '-h' || configFilePath === '--help' || configFilePath === 'help' || !configFilePath) {
   console.log(`graphql-flow
 
 Usage: graphql-flow [configFile.json] [filesToCrawl...]`);
   process.exit(1); // eslint-disable-line flowtype-errors/uncovered
 }
 
-const config = (0, _config.loadConfigFile)(configFile);
-const [schemaForValidation, schemaForTypeGeneration] = (0, _config.getSchemas)(config.schemaFilePath);
-const inputFiles = cliFiles.length ? cliFiles : findGraphqlTagReferences(process.cwd());
+const makeAbsPath = (maybeRelativePath, basePath) => {
+  return _path.default.isAbsolute(maybeRelativePath) ? maybeRelativePath : _path.default.join(basePath, maybeRelativePath);
+};
+
+const absConfigPath = makeAbsPath(configFilePath, process.cwd());
+const config = (0, _config.loadConfigFile)(absConfigPath);
+const inputFiles = cliFiles.length ? cliFiles : findGraphqlTagReferences(makeAbsPath(config.crawl.root, _path.default.dirname(absConfigPath)));
 /** Step (2) */
 
 const files = (0, _parse.processFiles)(inputFiles, f => {
@@ -110,22 +114,34 @@ if (errors.length) {
 console.log(Object.keys(resolved).length, 'resolved queries');
 /** Step (4) */
 
+const schemaCache = {};
+
+const getCachedSchemas = schemaFilePath => {
+  if (!schemaCache[schemaFilePath]) {
+    schemaCache[schemaFilePath] = (0, _config.getSchemas)(makeAbsPath(schemaFilePath, _path.default.dirname(absConfigPath)));
+  }
+
+  return schemaCache[schemaFilePath];
+};
+
 let validationFailures = 0;
 const printedOperations = [];
-Object.keys(resolved).forEach(k => {
+Object.keys(resolved).forEach(filePathAndLine => {
   const {
     document,
     raw
-  } = resolved[k];
-
-  if (config.excludes.some(rx => rx.test(raw.loc.path))) {
-    return; // skip
-  }
-
+  } = resolved[filePathAndLine];
   const hasNonFragments = document.definitions.some(({
     kind
   }) => kind !== 'FragmentDefinition');
-  const rawSource = raw.literals[0]; // eslint-disable-next-line flowtype-errors/uncovered
+  const rawSource = raw.literals[0];
+  const generateConfig = (0, _config.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 = (0, _apolloUtilities.addTypenameToDocument)(document);
   const printed = (0, _printer.print)(withTypeNames);
@@ -134,12 +150,18 @@ Object.keys(resolved).forEach(k => {
     printedOperations.push(printed);
   }
 
-  const processedOptions = (0, _generateTypeFiles.processPragmas)(config.options, rawSource);
+  const pragmaResult = (0, _generateTypeFiles.processPragmas)(generateConfig, config.crawl, rawSource);
 
-  if (!processedOptions) {
+  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 */
     const errors = (0, _validation.validate)(schemaForValidation, withTypeNames);
@@ -158,7 +180,7 @@ Object.keys(resolved).forEach(k => {
   }
 
   try {
-    (0, _generateTypeFiles.generateTypeFiles)(raw.loc.path, schemaForTypeGeneration, withTypeNames, processedOptions); // eslint-disable-next-line flowtype-errors/uncovered
+    (0, _generateTypeFiles.generateTypeFiles)(raw.loc.path, schemaForTypeGeneration, withTypeNames, generateConfig); // eslint-disable-next-line flowtype-errors/uncovered
   } catch (err) {
     console.error(`Error while generating operation from ${raw.loc.path}`);
     console.error(printed); // eslint-disable-next-line flowtype-errors/uncovered
@@ -174,8 +196,8 @@ if (validationFailures) {
   process.exit(1);
 }
 
-if (config.dumpOperations) {
-  const dumpOperations = config.dumpOperations;
+if (config.crawl.dumpOperations) {
+  const dumpOperations = config.crawl.dumpOperations;
   const parent = (0, _path.dirname)(dumpOperations);
   (0, _fs.mkdirSync)(parent, {
     recursive: true

package/dist/cli/run.js.flow

@@ -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(