Merge branch 'common-fields-unions' of https://github.com/ktosiek/relay-compiler-language-typescript into ktosiek-common-fields-unions

Author: alloy

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.