@khanacademy/graphql-flow 0.0.2 → 0.2.1

package/dist/cli/run.js.flow

@@ -0,0 +1,165 @@
+#!/usr/bin/env node
+// @flow
+/* eslint-disable no-console */
+import {generateTypeFiles, processPragmas} from '../generateTypeFiles';
+import {processFiles} from '../parser/parse';
+import {resolveDocuments} from '../parser/resolve';
+import {getSchemas, loadConfigFile} from './config';
+
+import {addTypenameToDocument} from 'apollo-utilities'; // eslint-disable-line flowtype-errors/uncovered
+
+import {execSync} from 'child_process';
+import {readFileSync} from 'fs';
+import {type DocumentNode} from 'graphql';
+import {print} from 'graphql/language/printer';
+import {validate} from 'graphql/validation';
+import path from 'path';
+
+/**
+ * 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: string): Array<string> => {
+    const response = 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.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 = loadConfigFile(configFile);
+
+const [schemaForValidation, schemaForTypeGeneration] = getSchemas(
+    config.schemaFilePath,
+);
+
+const inputFiles = cliFiles.length
+    ? cliFiles
+    : findGraphqlTagReferences(process.cwd());
+
+/** Step (2) */
+
+const files = processFiles(inputFiles, (f) => 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} = 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: number = 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: string = raw.literals[0];
+    const processedOptions = processPragmas(config.options, rawSource);
+    if (!processedOptions) {
+        return;
+    }
+
+    // eslint-disable-next-line flowtype-errors/uncovered
+    const withTypeNames: DocumentNode = addTypenameToDocument(document);
+    const printed = print(withTypeNames);
+
+    if (hasNonFragments) {
+        /* eslint-disable flowtype-errors/uncovered */
+        const errors = 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 {
+        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);
+}

package/dist/cli/run.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/cli/run.js"],"names":["findGraphqlTagReferences","root","response","encoding","cwd","trim","split","map","relative","path","join","_","__","configFile","cliFiles","process","argv","console","log","exit","config","schemaForValidation","schemaForTypeGeneration","schemaFilePath","inputFiles","length","files","f","filesHadErrors","Object","keys","forEach","key","file","errors","error","message","resolved","loc","validationFailures","k","document","raw","excludes","some","rx","test","hasNonFragments","definitions","kind","rawSource","literals","processedOptions","options","withTypeNames","printed","err"],"mappings":"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","sourcesContent":["#!/usr/bin/env node\n// @flow\n/* eslint-disable no-console */\nimport {generateTypeFiles, processPragmas} from '../generateTypeFiles';\nimport {processFiles} from '../parser/parse';\nimport {resolveDocuments} from '../parser/resolve';\nimport {getSchemas, loadConfigFile} from './config';\n\nimport {addTypenameToDocument} from 'apollo-utilities'; // eslint-disable-line flowtype-errors/uncovered\n\nimport {execSync} from 'child_process';\nimport {readFileSync} from 'fs';\nimport {type DocumentNode} from 'graphql';\nimport {print} from 'graphql/language/printer';\nimport {validate} from 'graphql/validation';\nimport path from 'path';\n\n/**\n * This CLI tool executes the following steps:\n * 1) process options\n * 2) crawl files to find all operations and fragments, with\n *   tagged template literals and expressions.\n * 3) resolve the found operations, passing the literals and\n *   fragments into the `graphql-tag` function to produce\n *   the DocumentNodes.\n * 4) generate types for all resolved Queries & Mutations\n */\n\n/** Step (1) */\n\nconst findGraphqlTagReferences = (root: string): Array<string> => {\n    const response = execSync(\n        \"git grep -I --word-regexp --name-only --fixed-strings 'graphql-tag' -- '*.js' '*.jsx'\",\n        {\n            encoding: 'utf8',\n            cwd: root,\n        },\n    );\n    return response\n        .trim()\n        .split('\\n')\n        .map((relative) => path.join(root, relative));\n};\n\nconst [_, __, configFile, ...cliFiles] = process.argv;\n\nif (\n    configFile === '-h' ||\n    configFile === '--help' ||\n    configFile === 'help' ||\n    !configFile\n) {\n    console.log(`graphql-flow\n\nUsage: graphql-flow [configFile.json] [filesToCrawl...]`);\n    process.exit(1); // eslint-disable-line flowtype-errors/uncovered\n}\n\nconst config = loadConfigFile(configFile);\n\nconst [schemaForValidation, schemaForTypeGeneration] = getSchemas(\n    config.schemaFilePath,\n);\n\nconst inputFiles = cliFiles.length\n    ? cliFiles\n    : findGraphqlTagReferences(process.cwd());\n\n/** Step (2) */\n\nconst files = processFiles(inputFiles, (f) => readFileSync(f, 'utf8'));\n\nlet filesHadErrors = false;\nObject.keys(files).forEach((key) => {\n    const file = files[key];\n    if (file.errors.length) {\n        filesHadErrors = true;\n        console.error(`Errors in ${file.path}`);\n        file.errors.forEach((error) => {\n            console.error(` - ${error.message}`);\n        });\n    }\n});\n\nif (filesHadErrors) {\n    console.error('Aborting');\n    process.exit(1); // eslint-disable-line flowtype-errors/uncovered\n}\n\n/** Step (3) */\n\nconst {resolved, errors} = resolveDocuments(files);\nif (errors.length) {\n    errors.forEach((error) => {\n        console.error(`Resolution error ${error.message} in ${error.loc.path}`);\n    });\n    console.error('Aborting');\n    process.exit(1); // eslint-disable-line flowtype-errors/uncovered\n}\n\nconsole.log(Object.keys(resolved).length, 'resolved queries');\n\n/** Step (4) */\n\nlet validationFailures: number = 0;\n\nObject.keys(resolved).forEach((k) => {\n    const {document, raw} = resolved[k];\n    if (config.excludes.some((rx) => rx.test(raw.loc.path))) {\n        return; // skip\n    }\n    const hasNonFragments = document.definitions.some(\n        ({kind}) => kind !== 'FragmentDefinition',\n    );\n    const rawSource: string = raw.literals[0];\n    const processedOptions = processPragmas(config.options, rawSource);\n    if (!processedOptions) {\n        return;\n    }\n\n    // eslint-disable-next-line flowtype-errors/uncovered\n    const withTypeNames: DocumentNode = addTypenameToDocument(document);\n    const printed = print(withTypeNames);\n\n    if (hasNonFragments) {\n        /* eslint-disable flowtype-errors/uncovered */\n        const errors = validate(schemaForValidation, withTypeNames);\n        /* eslint-disable flowtype-errors/uncovered */\n        if (errors.length) {\n            errors.forEach((error) => {\n                console.error(\n                    `Schema validation found errors for ${raw.loc.path}!`,\n                );\n                console.error(printed);\n                console.error(error);\n                validationFailures++;\n            });\n        }\n        /* eslint-enable flowtype-errors/uncovered */\n    }\n\n    try {\n        generateTypeFiles(\n            raw.loc.path,\n            schemaForTypeGeneration,\n            withTypeNames,\n            processedOptions,\n        );\n        // eslint-disable-next-line flowtype-errors/uncovered\n    } catch (err) {\n        console.error(`Error while generating operation from ${raw.loc.path}`);\n        console.error(printed);\n        // eslint-disable-next-line flowtype-errors/uncovered\n        console.error(err);\n        validationFailures++;\n    }\n});\n\nif (validationFailures) {\n    console.error(\n        `Encountered ${validationFailures} validation failures while printing types.`,\n    );\n    // eslint-disable-next-line flowtype-errors/uncovered\n    process.exit(1);\n}\n"],"file":"run.js"}

package/dist/enums.js

@@ -54,4 +54,5 @@ const scalarTypeToFlow = (config, name) => {
   return babelTypes.genericTypeAnnotation(babelTypes.identifier(`UNKNOWN_SCALAR["${name}"]`));
 };
 
-exports.scalarTypeToFlow = scalarTypeToFlow;
+exports.scalarTypeToFlow = scalarTypeToFlow;
+//# sourceMappingURL=enums.js.map

package/dist/enums.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/enums.js"],"names":["enumTypeToFlow","config","name","enumConfig","schema","enumsByName","combinedDescription","enumValues","map","n","description","replace","join","babelTypes","unionTypeAnnotation","stringLiteralTypeAnnotation","builtinScalars","Boolean","String","DateTime","Date","ID","Int","Float","scalarTypeToFlow","genericTypeAnnotation","identifier","underlyingType","scalars","errors","push"],"mappings":";;;;;;;AAIA;;AAGA;;;;;;AANA;AACA;AACA;AAMO,MAAMA,cAAc,GAAG,CAC1BC,MAD0B,EAE1BC,IAF0B,KAGN;AACpB,QAAMC,UAAU,GAAGF,MAAM,CAACG,MAAP,CAAcC,WAAd,CAA0BH,IAA1B,CAAnB;AACA,MAAII,mBAAmB,GAAGH,UAAU,CAACI,UAAX,CACrBC,GADqB,CAEjBC,CAAD,IACK,KAAIA,CAAC,CAACP,IAAK,EAAZ,IACCO,CAAC,CAACC,WAAF,GACK,eAAeD,CAAC,CAACC,WAAF,CAAcC,OAAd,CAAsB,KAAtB,EAA6B,UAA7B,CADpB,GAEK,EAHN,CAHc,EAQrBC,IARqB,CAQhB,IARgB,CAA1B;;AASA,MAAIT,UAAU,CAACO,WAAf,EAA4B;AACxBJ,IAAAA,mBAAmB,GACfH,UAAU,CAACO,WAAX,GAAyB,MAAzB,GAAkCJ,mBADtC;AAEH;;AACD,SAAO,uCACHA,mBADG,EAEHO,UAAU,CAACC,mBAAX,CACIX,UAAU,CAACI,UAAX,CAAsBC,GAAtB,CAA2BC,CAAD,IACtBI,UAAU,CAACE,2BAAX,CAAuCN,CAAC,CAACP,IAAzC,CADJ,CADJ,CAFG,CAAP;AAQH,CA1BM;;;AA4BA,MAAMc,cAAuC,GAAG;AACnDC,EAAAA,OAAO,EAAE,SAD0C;AAEnDC,EAAAA,MAAM,EAAE,QAF2C;AAGnDC,EAAAA,QAAQ,EAAE,QAHyC;AAInDC,EAAAA,IAAI,EAAE,QAJ6C;AAKnDC,EAAAA,EAAE,EAAE,QAL+C;AAMnDC,EAAAA,GAAG,EAAE,QAN8C;AAOnDC,EAAAA,KAAK,EAAE;AAP4C,CAAhD;;;AAUA,MAAMC,gBAAgB,GAAG,CAC5BvB,MAD4B,EAE5BC,IAF4B,KAGR;AACpB,MAAIc,cAAc,CAACd,IAAD,CAAlB,EAA0B;AACtB,WAAOW,UAAU,CAACY,qBAAX,CACHZ,UAAU,CAACa,UAAX,CAAsBV,cAAc,CAACd,IAAD,CAApC,CADG,CAAP;AAGH;;AACD,QAAMyB,cAAc,GAAG1B,MAAM,CAAC2B,OAAP,CAAe1B,IAAf,CAAvB;;AACA,MAAIyB,cAAc,IAAI,IAAtB,EAA4B;AACxB,WAAOd,UAAU,CAACY,qBAAX,CACHZ,UAAU,CAACa,UAAX,CAAsBC,cAAtB,CADG,CAAP;AAGH;;AACD1B,EAAAA,MAAM,CAAC4B,MAAP,CAAcC,IAAd,CACK,sBAAqB5B,IAAK,sFAD/B;AAGA,SAAOW,UAAU,CAACY,qBAAX,CACHZ,UAAU,CAACa,UAAX,CAAuB,mBAAkBxB,IAAK,IAA9C,CADG,CAAP;AAGH,CArBM","sourcesContent":["// @flow\n/**\n * Both input & output types can have enums & scalars.\n */\nimport * as babelTypes from '@babel/types';\nimport {type BabelNodeFlowType} from '@babel/types';\nimport type {Config} from './types';\nimport {maybeAddDescriptionComment} from './utils';\n\nexport const enumTypeToFlow = (\n    config: Config,\n    name: string,\n): BabelNodeFlowType => {\n    const enumConfig = config.schema.enumsByName[name];\n    let combinedDescription = enumConfig.enumValues\n        .map(\n            (n) =>\n                `- ${n.name}` +\n                (n.description\n                    ? '\\n\\n      ' + n.description.replace(/\\n/g, '\\n      ')\n                    : ''),\n        )\n        .join('\\n');\n    if (enumConfig.description) {\n        combinedDescription =\n            enumConfig.description + '\\n\\n' + combinedDescription;\n    }\n    return maybeAddDescriptionComment(\n        combinedDescription,\n        babelTypes.unionTypeAnnotation(\n            enumConfig.enumValues.map((n) =>\n                babelTypes.stringLiteralTypeAnnotation(n.name),\n            ),\n        ),\n    );\n};\n\nexport const builtinScalars: {[key: string]: string} = {\n    Boolean: 'boolean',\n    String: 'string',\n    DateTime: 'string',\n    Date: 'string',\n    ID: 'string',\n    Int: 'number',\n    Float: 'number',\n};\n\nexport const scalarTypeToFlow = (\n    config: Config,\n    name: string,\n): BabelNodeFlowType => {\n    if (builtinScalars[name]) {\n        return babelTypes.genericTypeAnnotation(\n            babelTypes.identifier(builtinScalars[name]),\n        );\n    }\n    const underlyingType = config.scalars[name];\n    if (underlyingType != null) {\n        return babelTypes.genericTypeAnnotation(\n            babelTypes.identifier(underlyingType),\n        );\n    }\n    config.errors.push(\n        `Unexpected scalar '${name}'! Please add it to the \"scalars\" argument at the callsite of 'generateFlowTypes()'.`,\n    );\n    return babelTypes.genericTypeAnnotation(\n        babelTypes.identifier(`UNKNOWN_SCALAR[\"${name}\"]`),\n    );\n};\n"],"file":"enums.js"}

package/dist/generateResponseType.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.unionOrInterfaceToFlow = exports.typeToFlow = exports.objectPropertiesToFlow = exports.generateResponseType = void 0;
+exports.unionOrInterfaceToFlow = exports.typeToFlow = exports.objectPropertiesToFlow = exports.generateResponseType = exports.generateFragmentType = void 0;
 
 var _generator = _interopRequireDefault(require("@babel/generator"));
 
@@ -29,6 +29,55 @@ const generateResponseType = (schema, query, config) => {
 
 exports.generateResponseType = generateResponseType;
 
+const sortedObjectTypeAnnotation = (config, properties) => {
+  const obj = babelTypes.objectTypeAnnotation(properties.sort((a, b) => {
+    if (a.type === 'ObjectTypeProperty' && b.type === 'ObjectTypeProperty') {
+      const aName = a.key.type === 'Identifier' ? a.key.name : '';
+      const bName = b.key.type === 'Identifier' ? b.key.name : '';
+      return aName < bName ? -1 : 1;
+    }
+
+    return 0;
+  }), undefined
+  /* indexers */
+  , undefined
+  /* callProperties */
+  , undefined
+  /* internalSlots */
+  , true
+  /* exact */
+  );
+  const name = config.path.join('_');
+  const isTopLevelType = config.path.length <= 1;
+
+  if (config.allObjectTypes != null && !isTopLevelType) {
+    config.allObjectTypes[name] = obj;
+    return babelTypes.genericTypeAnnotation(babelTypes.identifier(name));
+  } else {
+    return obj;
+  }
+};
+
+const generateFragmentType = (schema, fragment, config) => {
+  const onType = fragment.typeCondition.name.value;
+  let ast;
+
+  if (schema.typesByName[onType]) {
+    ast = sortedObjectTypeAnnotation(config, objectPropertiesToFlow(config, schema.typesByName[onType], onType, fragment.selectionSet.selections));
+  } else if (schema.interfacesByName[onType]) {
+    ast = unionOrInterfaceToFlow(config, config.schema.interfacesByName[onType], fragment.selectionSet.selections);
+  } else if (schema.unionsByName[onType]) {
+    ast = unionOrInterfaceToFlow(config, config.schema.unionsByName[onType], fragment.selectionSet.selections);
+  } else {
+    throw new Error(`Unknown ${onType}`);
+  } // eslint-disable-next-line flowtype-errors/uncovered
+
+
+  return (0, _generator.default)(ast).code;
+};
+
+exports.generateFragmentType = generateFragmentType;
+
 const _typeToFlow = (config, type, selection) => {
   if (type.kind === 'SCALAR') {
     return (0, _enums.scalarTypeToFlow)(config, type.name);
@@ -103,35 +152,50 @@ const typeToFlow = (config, type, selection) => {
 
 exports.typeToFlow = typeToFlow;
 
-const querySelectionToObjectType = (config, selections, type, typeName) => {
+const ensureOnlyOneTypenameProperty = properties => {
   let seenTypeName = false;
-  return babelTypes.objectTypeAnnotation(objectPropertiesToFlow(config, type, typeName, selections).filter(type => {
+  return properties.filter(type => {
     // The apollo-utilities "addTypeName" utility will add it
     // even if it's already specified :( so we have to filter out
     // the extra one here.
     if (type.type === 'ObjectTypeProperty' && type.key.name === '__typename') {
+      const name = type.value.type === 'StringLiteralTypeAnnotation' ? type.value.value : 'INVALID';
+
       if (seenTypeName) {
+        if (name !== seenTypeName) {
+          throw new Error(`Got two different type names ${name}, ${seenTypeName}`);
+        }
+
         return false;
       }
 
-      seenTypeName = true;
+      seenTypeName = name;
     }
 
     return true;
-  }), undefined
-  /* indexers */
-  , undefined
-  /* callProperties */
-  , undefined
-  /* internalSlots */
-  , true
-  /* exact */
-  );
+  });
+};
+
+const querySelectionToObjectType = (config, selections, type, typeName) => {
+  return sortedObjectTypeAnnotation(config, ensureOnlyOneTypenameProperty(objectPropertiesToFlow(config, type, typeName, selections)));
 };
 
 const objectPropertiesToFlow = (config, type, typeName, selections) => {
   return [].concat(...selections.map(selection => {
     switch (selection.kind) {
+      case 'InlineFragment':
+        {
+          var _selection$typeCondit;
+
+          const newTypeName = ((_selection$typeCondit = selection.typeCondition) === null || _selection$typeCondit === void 0 ? void 0 : _selection$typeCondit.name.value) ?? typeName;
+
+          if (newTypeName !== typeName) {
+            return [];
+          }
+
+          return objectPropertiesToFlow(config, config.schema.typesByName[newTypeName], newTypeName, selection.selectionSet.selections);
+        }
+
       case 'FragmentSpread':
         if (!config.fragments[selection.name.value]) {
           config.errors.push(`No fragment named '${selection.name.value}'. Did you forget to include it in the template literal?`);
@@ -154,10 +218,13 @@ const objectPropertiesToFlow = (config, type, typeName, selections) => {
         }
 
         const typeField = type.fieldsByName[name];
-        return [(0, _utils.maybeAddDescriptionComment)(typeField.description, (0, _utils.liftLeadingPropertyComments)(babelTypes.objectTypeProperty(babelTypes.identifier(alias), typeToFlow(config, typeField.type, selection))))];
+        return [(0, _utils.maybeAddDescriptionComment)(typeField.description, (0, _utils.liftLeadingPropertyComments)(babelTypes.objectTypeProperty(babelTypes.identifier(alias), typeToFlow({ ...config,
+          path: config.path.concat([alias])
+        }, typeField.type, selection))))];
 
       default:
-        config.errors.push(`Unsupported selection kind '${selection.kind}'`);
+        config.errors.push( // eslint-disable-next-line flowtype-errors/uncovered
+        `Unsupported selection kind '${selection.kind}'`);
         return [];
     }
   }));
@@ -166,46 +233,80 @@ const objectPropertiesToFlow = (config, type, typeName, selections) => {
 exports.objectPropertiesToFlow = objectPropertiesToFlow;
 
 const unionOrInterfaceToFlow = (config, type, selections) => {
-  const selectedAttributes = type.possibleTypes.map(possible => {
-    let seenTypeName = false;
-    return selections.map(selection => unionOrInterfaceSelection(config, type, possible, selection)).flat().filter(type => {
-      // The apollo-utilities "addTypeName" utility will add it
-      // even if it's already specified :( so we have to filter out
-      // the extra one here.
-      if (type.type === 'ObjectTypeProperty' && type.key.name === '__typename') {
-        if (seenTypeName) {
-          return false;
-        }
-
-        seenTypeName = true;
-      }
-
-      return true;
-    });
-  });
   const allFields = selections.every(selection => selection.kind === 'Field');
+  const selectedAttributes = type.possibleTypes.slice().sort((a, b) => {
+    return a.name < b.name ? -1 : 1;
+  }).map(possible => {
+    const configWithUpdatedPath = { ...config,
+      path: allFields ? config.path : config.path.concat([possible.name])
+    };
+    return {
+      typeName: possible.name,
+      attributes: ensureOnlyOneTypenameProperty(selections.map(selection => unionOrInterfaceSelection(configWithUpdatedPath, type, possible, selection)).flat())
+    };
+  }); // If they're all fields, the only selection that could be different is __typename
+
+  if (allFields) {
+    const sharedAttributes = selectedAttributes[0].attributes.slice();
+    const typeNameIndex = selectedAttributes[0].attributes.findIndex(x => x.type === 'ObjectTypeProperty' && x.key.type === 'Identifier' && x.key.name === '__typename');
+
+    if (typeNameIndex !== -1) {
+      sharedAttributes[typeNameIndex] = babelTypes.objectTypeProperty(babelTypes.identifier('__typename'), babelTypes.unionTypeAnnotation(selectedAttributes.map(attrs => // eslint-disable-next-line flowtype-errors/uncovered
+      attrs.attributes[typeNameIndex].value)));
+    }
 
-  if (selectedAttributes.length === 1 || allFields) {
-    return babelTypes.objectTypeAnnotation(selectedAttributes[0], undefined
-    /* indexers */
-    , undefined
-    /* callProperties */
-    , undefined
-    /* internalSlots */
-    , true
-    /* exact */
-    );
+    return sortedObjectTypeAnnotation(config, sharedAttributes);
   }
 
-  return babelTypes.unionTypeAnnotation(selectedAttributes.map(properties => babelTypes.objectTypeAnnotation(properties, undefined
-  /* indexers */
-  , undefined
-  /* callProperties */
-  , undefined
-  /* internalSlots */
-  , true
-  /* exact */
-  )));
+  if (selectedAttributes.length === 1) {
+    return sortedObjectTypeAnnotation(config, selectedAttributes[0].attributes);
+  }
+  /**
+   * When generating the objects for the sub-options of a union, the path needs
+   * to include the name of the object type.
+   * ```
+   * query getFriend {
+   *     friend {
+   *         ... on Human { id }
+   *         ... on Droid { arms }
+   *     }
+   * }
+   * ```
+   * produces
+   * ```
+   * type getFriend = {friend: getFriend_friend_Human | getFriend_friend_Droid }
+   * type getFriend_friend_Human = {id: string}
+   * type getFriend_friend_Droid = {arms: number}
+   * ```
+   * Note that this is different from when an attribute has a plain object type.
+   * ```
+   * query getHuman {
+   *     me: human(id: "me") { id }
+   * }
+   * ```
+   * produces
+   * ```
+   * type getHuman = {me: getHuman_me}
+   * type getHuman_me = {id: string}
+   * ```
+   * instead of e.g. `getHuman_me_Human`.
+   */
+
+
+  const result = babelTypes.unionTypeAnnotation(selectedAttributes.map(({
+    typeName,
+    attributes
+  }) => sortedObjectTypeAnnotation({ ...config,
+    path: config.path.concat([typeName])
+  }, attributes)));
+  const name = config.path.join('_');
+
+  if (config.allObjectTypes && config.path.length > 1) {
+    config.allObjectTypes[name] = result;
+    return babelTypes.genericTypeAnnotation(babelTypes.identifier(name));
+  }
+
+  return result;
 };
 
 exports.unionOrInterfaceToFlow = unionOrInterfaceToFlow;
@@ -227,11 +328,18 @@ const unionOrInterfaceSelection = (config, type, possible, selection) => {
     }
 
     const typeField = type.fieldsByName[name];
-    return [(0, _utils.liftLeadingPropertyComments)(babelTypes.objectTypeProperty(babelTypes.identifier(alias), typeToFlow(config, typeField.type, selection)))];
+    return [(0, _utils.liftLeadingPropertyComments)(babelTypes.objectTypeProperty(babelTypes.identifier(alias), typeToFlow({ ...config,
+      path: config.path.concat([name])
+    }, typeField.type, selection)))];
   }
 
   if (selection.kind === 'FragmentSpread') {
     const fragment = config.fragments[selection.name.value];
+
+    if (!fragment) {
+      throw new Error(`Unknown fragment ${selection.name.value}`);
+    }
+
     const typeName = fragment.typeCondition.name.value;
 
     if (config.schema.interfacesByName[typeName] && config.schema.interfacesByName[typeName].possibleTypesByName[possible.name] || typeName === possible.name) {
@@ -253,15 +361,17 @@ Try using an inline fragment "... on SomeType {}".`);
     return [];
   }
 
-  if (!selection.typeCondition) {
-    throw new Error('Expected selection to have a typeCondition');
-  }
+  if (selection.typeCondition) {
+    var _config$schema$interf;
 
-  const typeName = selection.typeCondition.name.value;
+    const typeName = selection.typeCondition.name.value;
+    const indirectMatch = (_config$schema$interf = config.schema.interfacesByName[typeName]) === null || _config$schema$interf === void 0 ? void 0 : _config$schema$interf.possibleTypesByName[possible.name];
 
-  if (config.schema.interfacesByName[typeName] && config.schema.interfacesByName[typeName].possibleTypesByName[possible.name] || typeName === possible.name) {
-    return objectPropertiesToFlow(config, config.schema.typesByName[possible.name], possible.name, selection.selectionSet.selections);
+    if (typeName !== possible.name && !indirectMatch) {
+      return [];
+    }
   }
 
-  return [];
-};
+  return objectPropertiesToFlow(config, config.schema.typesByName[possible.name], possible.name, selection.selectionSet.selections);
+};
+//# sourceMappingURL=generateResponseType.js.map