@khanacademy/graphql-flow 0.0.1 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # @khanacademy/graphql-flow
 
+## 0.2.0
+
+### Minor Changes
+
+-   d9a8229: Generate types for fragments!
+
+### Patch Changes
+
+-   7497164: Fix a bug in index file generation that resulted in duplicate entries
+-   26abf9b: Add options for specifying the name of the generated directory, and for exporting the response and variables types.
+
+## 0.1.0
+
+### Minor Changes
+
+-   b08ed1b: Build out a cli tool that does our own parsing of javascript files, dramatically speeding things up!
+
+### Patch Changes
+
+-   8cdcdc2: Support inline fragments on objects
+-   fd5c6b7: Allow schema to be provided as a .graphql file, not just .json
+-   6869203: Add 'ignorePragma' option, to allow skipping of documents
+
+## 0.0.2
+
+### Patch Changes
+
+-   9810bfe: Allow customization of the "regenerate command" that's in the file docstrings
+-   7d27337: Support custom scalars as variables in an operation
+
 ## 0.0.1
 
 ### Patch Changes

package/Readme.md

@@ -2,64 +2,84 @@
 
 This is a tool for generating flow types from graphql queries in javascript frontends.
 
-The core of this tool is the `documentToFlowTypes` function, which takes a `DocumentNode` (such as is returned by the `graphql-tag` package) as well as your backend's graphql schema (see below for instructions on how to produce this), and produces a list of stringified flow types, one for each query and mutation defined in that graphql block.
+## Using as a CLI tool
 
-It looks something like this:
+Write a config file, with the following options:
 
-```js
-import gql from 'graphql-tag';
-import {documentToFlowTypes, schemaFromIntrospectionData} from 'graphql-flow';
-import myIntrospectionData from './server-introspection-response.json';
-
-const schema = schemaFromIntrospectionData(myIntrospectionData);
-
-const MyQuery = gql`
-    query SomeQuery {
-        human(id: "Han Solo") {
-            id
-            name
-            homePlanet
-            friends {
-                name
-            }
+```json
+{
+    // Response to the "introspection query" (see below), or a .graphql schema file.
+    // The file extension indicates the format, .json or .graphql (default .json).
+    // This path is resolved relative to the config file location.
+    "schemaFilePath": "../some/schema-file.json",
+    // List of regexes
+    "excludes": ["\\bsome-thing", "_test.jsx?$"],
+    // Options for type generation (see below)
+    "options": {
+        "scalars": {
+            "JSONString": "string"
         }
     }
-`;
-
-console.log(documentToFlowTypes(MyQuery, schema))
-/*
-export type SomeQueryResponseType = {|
-    human: ?{|
-        id: string,
-        name: ?string,
-        homePlanet: ?string,
-        friends: ?$ReadOnlyArray<?{|
-            name: ?string
-        |}>,
-    |}
-|};
-*/
+}
+```
+
+Then run from the CLI, like so:
+
+```bash
+$ graphql-flow path/to/config.json
 ```
 
-If you already have a setup whereby you collect all of your graphql literals, that may be all you need!
+Files will be discovered relative to the current working directory.
 
-Otherwise, we provide a way to hook into jest to automatically collect your queries and generate the types.
+To specify what file should be checked, pass them in as subsequent cli arguments.
 
-## Options for `documentToFlowTypes`
+## Options (for the cli 'options' config item, or when running from jest):
 
-```js
-{
-    // Use nullable types where the graphql type is nullable. Included for legacy compatability,
-    // will probably remove once the mobile repo no longer needs it.
+```ts
+type Options = {
+    // These are from the `documentToFlowTypes` options object above
     strictNullability: boolean = true,
-    // Output `$ReadOnlyArray<>` instead of `Array<>`, for stricter flow typing. On by default.
     readOnlyArray: boolean = true,
-    // A mapping of custom scalar names to the underlying json representation.
     scalars: {[key: string]: 'string' | 'boolean' | 'number'}
+
+    // Specify the name of the generated types directory
+    generatedDirectory: string = '__generated__',
+
+    // The default generated type contains both the types of the response
+    // and the variables, combined as [operatioName]Type. Setting
+    // `splitTypes = true` adds the additional exports [operationName]
+    // (for the response) and [operationName]Variables (for the variables).
+    splitTypes?: boolean,
+
+    // Specify an opt-in pragma that must be present in a graphql string source
+    // in order for it to be picked up and processed
+    // e.g. set this to `"# @autogen\n"` to only generate types for queries that
+    // have the comment `# @autogen` in them.
+    pragma?: string,
+    // Specify a pragma that will turn off `strictNullability` for that
+    // source file. e.g. `"# @autogen-loose\n"`.
+    loosePragma?: string,
+    // If neither pragma nor loosePragma are specified, all graphql documents
+    // that contain a query or mutation will be processed.
+
+    // Any graphql operations containing ignorePragma will be skipped
+    ignorePragma?: string,
+
+    // Set to true to mirror gqlgen's behavior of exporting all
+    // nested object types within the response type.
+    // Names are generated by concatenating the attribute names
+    // of the path to the object type, separated by underscores.
+    exportAllObjectTypes?: boolean,
 }
 ```
 
-## Using jest to do the heavy lifting:
+## Using from jest
+
+You can also use jest to do the heavy lifting, running all of your code and collecting queries
+by mocking out the `graphql-tag` function itself. This requires that all graphql operations are
+defined at the top level (no queries defined in functions or components, for example), but does
+support complicated things like returning a fragment from a function (which is probably
+not a great idea code-style-wise anyway).
 
 ### jest-setup.js
 
@@ -74,6 +94,7 @@ if (process.env.GRAPHQL_FLOW) {
 
         return jest.requireActual('../tools/graphql-flow/jest-mock-graphql-tag.js')(
             introspectionData,
+            // See "Options" type above
             {
                 pragma: '# @autogen\n',
                 loosePragma: '# @autogen-loose\n',
@@ -94,10 +115,11 @@ Then you'll want to make a pseudo-'test' that makes sure to 'require' all of the
 jest will process them and our mock will see them. 
 ```js
 // generate-types.test.js
-import {findFilesWithQueries} from '../tools/graphql-flow/find-files-with-gql';
+import {findGraphqlTagReferences} from '../tools/graphql-flow/find-files-with-gql';
+import path from 'path';
 
 if (process.env.GRAPHQL_FLOW) {
-    findFilesWithQueries(path.join(__dirname, '..')).forEach(name => {
+    findGraphqlTagReferences(path.join(__dirname, '..')).forEach(name => {
         require(name);
     });
 
@@ -125,28 +147,6 @@ And then `yarn generate-types` or `npm run generate-types` gets your types gener
 
 🚀
 
-### Options for the `jest-mock-graphql-tag.js` helper:
-
-```js
-{
-    // These are from the `documentToFlowTypes` options object above
-    strictNullability: boolean = true,
-    readOnlyArray: boolean = true,
-    scalars: {[key: string]: 'string' | 'boolean' | 'number'}
-
-    // Specify an opt-in pragma that must be present in a graphql string source
-    // in order for it to be picked up and processed
-    // e.g. set this to `"# @autogen\n"` to only generate types for queries that
-    // have the comment `# @autogen` in them.
-    pragma?: string,
-    // Specify a pragma that will turn off `strictNullability` for that
-    // source file. e.g. `"# @autogen-loose\n"`.
-    loosePragma?: string,
-    // If neither pragma nor loosePragma are specified, all graphql documents
-    // that contain a query or mutation will be processed.
-}
-```
-
 ## 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':
 

package/dist/cli/config.js

@@ -0,0 +1,73 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.loadConfigFile = exports.getSchemas = void 0;
+
+var _schemaFromIntrospectionData = require("../schemaFromIntrospectionData");
+
+var _fs = _interopRequireDefault(require("fs"));
+
+var _graphql = require("graphql");
+
+var _path = _interopRequireDefault(require("path"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const loadConfigFile = configFile => {
+  var _data$excludes;
+
+  // eslint-disable-next-line flowtype-errors/uncovered
+  const data = JSON.parse(_fs.default.readFileSync(configFile, 'utf8'));
+  const toplevelKeys = ['excludes', 'schemaFilePath', 'options'];
+  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'];
+    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 = data.excludes) === null || _data$excludes === void 0 ? void 0 : _data$excludes.map(string => new RegExp(string))) ?? [],
+    schemaFilePath: _path.default.join(_path.default.dirname(configFile), data.schemaFilePath)
+  };
+};
+/**
+ * Loads a .json 'introspection query response', or a .graphql schema definition.
+ */
+
+
+exports.loadConfigFile = loadConfigFile;
+
+const getSchemas = schemaFilePath => {
+  const raw = _fs.default.readFileSync(schemaFilePath, 'utf8');
+
+  if (schemaFilePath.endsWith('.graphql')) {
+    const schemaForValidation = (0, _graphql.buildSchema)(raw);
+    const queryResponse = (0, _graphql.graphqlSync)(schemaForValidation, (0, _graphql.getIntrospectionQuery)({
+      descriptions: true
+    }));
+    const schemaForTypeGeneration = (0, _schemaFromIntrospectionData.schemaFromIntrospectionData)( // eslint-disable-next-line flowtype-errors/uncovered
+    queryResponse.data);
+    return [schemaForValidation, schemaForTypeGeneration];
+  } else {
+    // eslint-disable-next-line flowtype-errors/uncovered
+    const introspectionData = JSON.parse(raw);
+    const schemaForValidation = (0, _graphql.buildClientSchema)(introspectionData);
+    const schemaForTypeGeneration = (0, _schemaFromIntrospectionData.schemaFromIntrospectionData)(introspectionData);
+    return [schemaForValidation, schemaForTypeGeneration];
+  }
+};
+
+exports.getSchemas = getSchemas;
+//# sourceMappingURL=config.js.map

package/dist/cli/config.js.flow

@@ -0,0 +1,104 @@
+// @flow
+import type {ExternalOptions} from '../generateTypeFiles';
+import type {Schema} from '../types';
+import type {GraphQLSchema} from 'graphql/type/schema';
+
+import {schemaFromIntrospectionData} from '../schemaFromIntrospectionData';
+
+import fs from 'fs';
+import {
+    buildClientSchema,
+    buildSchema,
+    getIntrospectionQuery,
+    graphqlSync,
+    type IntrospectionQuery,
+} from 'graphql';
+import path from 'path';
+
+export type CliConfig = {
+    excludes: Array<RegExp>,
+    schemaFilePath: string,
+    options: ExternalOptions,
+};
+
+/**
+ * This is the json-compatible form of the config
+ * object.
+ */
+type JSONConfig = {
+    excludes?: Array<string>,
+    schemaFilePath: string,
+    options?: ExternalOptions,
+};
+
+export const loadConfigFile = (configFile: string): CliConfig => {
+    // eslint-disable-next-line flowtype-errors/uncovered
+    const data: JSONConfig = JSON.parse(fs.readFileSync(configFile, 'utf8'));
+    const toplevelKeys = ['excludes', 'schemaFilePath', 'options'];
+    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',
+        ];
+        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,
+        ),
+    };
+};
+
+/**
+ * Loads a .json 'introspection query response', or a .graphql schema definition.
+ */
+export const getSchemas = (schemaFilePath: string): [GraphQLSchema, Schema] => {
+    const raw = fs.readFileSync(schemaFilePath, 'utf8');
+    if (schemaFilePath.endsWith('.graphql')) {
+        const schemaForValidation = buildSchema(raw);
+        const queryResponse = graphqlSync(
+            schemaForValidation,
+            getIntrospectionQuery({descriptions: true}),
+        );
+        const schemaForTypeGeneration = schemaFromIntrospectionData(
+            // eslint-disable-next-line flowtype-errors/uncovered
+            ((queryResponse.data: any): IntrospectionQuery),
+        );
+        return [schemaForValidation, schemaForTypeGeneration];
+    } else {
+        // eslint-disable-next-line flowtype-errors/uncovered
+        const introspectionData: IntrospectionQuery = JSON.parse(raw);
+        const schemaForValidation = buildClientSchema(introspectionData);
+        const schemaForTypeGeneration =
+            schemaFromIntrospectionData(introspectionData);
+        return [schemaForValidation, schemaForTypeGeneration];
+    }
+};

package/dist/cli/config.js.map

@@ -0,0 +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","getSchemas","raw","endsWith","schemaForValidation","queryResponse","descriptions","schemaForTypeGeneration","introspectionData"],"mappings":";;;;;;;AAKA;;AAEA;;AACA;;AAOA;;;;AAkBO,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,CAAC,UAAD,EAAa,gBAAb,EAA+B,SAA/B,CAArB;AACAC,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,CAA5B;AAYAR,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,EAAEb,IAAI,CAACa,OAAL,IAAgB,EADtB;AAEHE,IAAAA,QAAQ,EAAE,mBAAAf,IAAI,CAACe,QAAL,kEAAeC,GAAf,CAAoBC,MAAD,IAAY,IAAIC,MAAJ,CAAWD,MAAX,CAA/B,MAAsD,EAF7D;AAGHE,IAAAA,cAAc,EAAEC,cAAKR,IAAL,CACZQ,cAAKC,OAAL,CAAatB,UAAb,CADY,EAEZC,IAAI,CAACmB,cAFO;AAHb,GAAP;AAQH,CA5CM;AA8CP;AACA;AACA;;;;;AACO,MAAMG,UAAU,GAAIH,cAAD,IAAqD;AAC3E,QAAMI,GAAG,GAAGpB,YAAGC,YAAH,CAAgBe,cAAhB,EAAgC,MAAhC,CAAZ;;AACA,MAAIA,cAAc,CAACK,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,CAAC1B,IAFY,CAAhC;AAIA,WAAO,CAACyB,mBAAD,EAAsBG,uBAAtB,CAAP;AACH,GAXD,MAWO;AACH;AACA,UAAMC,iBAAqC,GAAG5B,IAAI,CAACC,KAAL,CAAWqB,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    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};\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 = ['excludes', 'schemaFilePath', 'options'];\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        ];\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    };\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"}

package/dist/cli/run.js

@@ -0,0 +1,157 @@
+"use strict";
+
+var _generateTypeFiles = require("../generateTypeFiles");
+
+var _parse = require("../parser/parse");
+
+var _resolve = require("../parser/resolve");
+
+var _config = require("./config");
+
+var _apolloUtilities = require("apollo-utilities");
+
+var _child_process = require("child_process");
+
+var _fs = require("fs");
+
+var _printer = require("graphql/language/printer");
+
+var _validation = require("graphql/validation");
+
+var _path = _interopRequireDefault(require("path"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/* eslint-disable no-console */
+// eslint-disable-line flowtype-errors/uncovered
+
+/**
+ * This CLI tool executes the following steps:
+ * 1) process options
+ * 2) crawl files to find all operations and fragments, with
+ *   tagged template literals and expressions.
+ * 3) resolve the found operations, passing the literals and
+ *   fragments into the `graphql-tag` function to produce
+ *   the DocumentNodes.
+ * 4) generate types for all resolved Queries & Mutations
+ */
+
+/** Step (1) */
+const findGraphqlTagReferences = root => {
+  const response = (0, _child_process.execSync)("git grep -I --word-regexp --name-only --fixed-strings 'graphql-tag' -- '*.js' '*.jsx'", {
+    encoding: 'utf8',
+    cwd: root
+  });
+  return response.trim().split('\n').map(relative => _path.default.join(root, relative));
+};
+
+const [_, __, configFile, ...cliFiles] = process.argv;
+
+if (configFile === '-h' || configFile === '--help' || configFile === 'help' || !configFile) {
+  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());
+/** Step (2) */
+
+const files = (0, _parse.processFiles)(inputFiles, f => (0, _fs.readFileSync)(f, 'utf8'));
+let filesHadErrors = false;
+Object.keys(files).forEach(key => {
+  const file = files[key];
+
+  if (file.errors.length) {
+    filesHadErrors = true;
+    console.error(`Errors in ${file.path}`);
+    file.errors.forEach(error => {
+      console.error(` - ${error.message}`);
+    });
+  }
+});
+
+if (filesHadErrors) {
+  console.error('Aborting');
+  process.exit(1); // eslint-disable-line flowtype-errors/uncovered
+}
+/** Step (3) */
+
+
+const {
+  resolved,
+  errors
+} = (0, _resolve.resolveDocuments)(files);
+
+if (errors.length) {
+  errors.forEach(error => {
+    console.error(`Resolution error ${error.message} in ${error.loc.path}`);
+  });
+  console.error('Aborting');
+  process.exit(1); // eslint-disable-line flowtype-errors/uncovered
+}
+
+console.log(Object.keys(resolved).length, 'resolved queries');
+/** Step (4) */
+
+let validationFailures = 0;
+Object.keys(resolved).forEach(k => {
+  const {
+    document,
+    raw
+  } = resolved[k];
+
+  if (config.excludes.some(rx => rx.test(raw.loc.path))) {
+    return; // skip
+  }
+
+  const hasNonFragments = document.definitions.some(({
+    kind
+  }) => kind !== 'FragmentDefinition');
+  const rawSource = raw.literals[0];
+  const processedOptions = (0, _generateTypeFiles.processPragmas)(config.options, rawSource);
+
+  if (!processedOptions) {
+    return;
+  } // eslint-disable-next-line flowtype-errors/uncovered
+
+
+  const withTypeNames = (0, _apolloUtilities.addTypenameToDocument)(document);
+  const printed = (0, _printer.print)(withTypeNames);
+
+  if (hasNonFragments) {
+    /* eslint-disable flowtype-errors/uncovered */
+    const errors = (0, _validation.validate)(schemaForValidation, withTypeNames);
+    /* eslint-disable flowtype-errors/uncovered */
+
+    if (errors.length) {
+      errors.forEach(error => {
+        console.error(`Schema validation found errors for ${raw.loc.path}!`);
+        console.error(printed);
+        console.error(error);
+        validationFailures++;
+      });
+    }
+    /* eslint-enable flowtype-errors/uncovered */
+
+  }
+
+  try {
+    (0, _generateTypeFiles.generateTypeFiles)(raw.loc.path, schemaForTypeGeneration, withTypeNames, processedOptions); // 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
+
+    console.error(err);
+    validationFailures++;
+  }
+});
+
+if (validationFailures) {
+  console.error(`Encountered ${validationFailures} validation failures while printing types.`); // eslint-disable-next-line flowtype-errors/uncovered
+
+  process.exit(1);
+}
+//# sourceMappingURL=run.js.map