Generate a discriminated union whenever possible

This commit forces generating the discriminated union
if there are any fragments on concrete types.
It also always adds the "optional base fields" types,
so it shouldn't break users that depend on them.

Author: ktosiek

src/TypeScriptGenerator.ts

@@ -93,7 +93,7 @@ function selectionsToAST(
   state: State,
   refTypeName?: string
 ): ts.TypeNode {
-  const baseFields = new Map();
+  const baseFields = new Map<string, Selection>();
   const byConcreteType: { [type: string]: Selection[] } = {};
 
   flattenArray(selections).forEach(selection => {
@@ -112,26 +112,21 @@ function selectionsToAST(
   });
 
   const types: ts.PropertySignature[][] = [];
+  const discriminators = Array.from(baseFields.values()).filter(
+    isTypenameSelection
+  );
+  for (const concreteType in byConcreteType) {
+    types.push(
+      groupRefs([...discriminators, ...byConcreteType[concreteType]]).map(
+        selection => makeProp(selection, state, concreteType)
+      )
+    );
+  }
 
-  if (
-    Object.keys(byConcreteType).length &&
-    onlySelectsTypename(Array.from(baseFields.values())) &&
-    (hasTypenameSelection(Array.from(baseFields.values())) ||
-      Object.keys(byConcreteType).every(type =>
-        hasTypenameSelection(byConcreteType[type])
-      ))
-  ) {
-    for (const concreteType in byConcreteType) {
-      types.push(
-        groupRefs([
-          ...Array.from(baseFields.values()),
-          ...byConcreteType[concreteType]
-        ]).map(selection => makeProp(selection, state, concreteType))
-      );
-    }
-    // It might be some other type than the listed concrete types. Ideally, we
-    // would set the type to diff(string, set of listed concrete types), but
-    // this doesn't exist in Flow at the time.
+  if (types.length) {
+    // It might be some other type than the listed concrete types.
+    // Ideally, we would set the type to Exclude<string, set of listed concrete types>,
+    // but this doesn't work with TypeScript's discriminated unions.
     const otherProp = readOnlyObjectTypeProperty(
       "__typename",
       ts.createLiteralTypeNode(ts.createLiteral("%other"))
@@ -144,44 +139,51 @@ function selectionsToAST(
       true
     );
     types.push([otherPropWithComment]);
-  } else {
-    let selectionMap = selectionsToMap(Array.from(baseFields.values()));
-    for (const concreteType in byConcreteType) {
-      selectionMap = mergeSelections(
-        selectionMap,
-        selectionsToMap(
-          byConcreteType[concreteType].map(sel => ({
-            ...sel,
-            conditional: true
-          }))
-        )
-      );
-    }
-    const selectionMapValues = groupRefs(Array.from(selectionMap.values())).map(
-      sel =>
-        isTypenameSelection(sel) && sel.concreteType
-          ? makeProp({ ...sel, conditional: false }, state, sel.concreteType)
-          : makeProp(sel, state)
-    );
-    types.push(selectionMapValues);
   }
 
-  return ts.createUnionTypeNode(
-    types.map(props => {
-      if (refTypeName) {
-        props.push(
-          readOnlyObjectTypeProperty(
-            REF_TYPE,
-            ts.createTypeReferenceNode(
-              ts.createIdentifier(refTypeName),
-              undefined
-            )
-          )
-        );
-      }
-      return exactObjectTypeAnnotation(props);
-    })
+  let selectionMap = selectionsToMap(Array.from(baseFields.values()));
+  for (const concreteType in byConcreteType) {
+    selectionMap = mergeSelections(
+      selectionMap,
+      selectionsToMap(
+        byConcreteType[concreteType].map(sel => ({
+          ...sel,
+          conditional: true
+        }))
+      )
+    );
+  }
+  const baseProps: ts.PropertySignature[] = groupRefs(
+    Array.from(selectionMap.values())
+  ).map(
+    sel =>
+      isTypenameSelection(sel) && sel.concreteType
+        ? makeProp({ ...sel, conditional: false }, state, sel.concreteType)
+        : makeProp(sel, state)
   );
+
+  if (refTypeName) {
+    baseProps.push(
+      readOnlyObjectTypeProperty(
+        REF_TYPE,
+        ts.createTypeReferenceNode(ts.createIdentifier(refTypeName), undefined)
+      )
+    );
+  }
+
+  if (types.length > 0) {
+    const unionType = ts.createUnionTypeNode(
+      types.map(props => {
+        return exactObjectTypeAnnotation(props);
+      })
+    );
+    return ts.createIntersectionTypeNode([
+      exactObjectTypeAnnotation(baseProps),
+      unionType
+    ]);
+  } else {
+    return exactObjectTypeAnnotation(baseProps);
+  }
 }
 
 // We don't have exact object types in typescript.