Report selectionsToBabel -> selectionsToAST to fixup union type decls

See the changes in the tests. This should allow much easier work with
types that can take many different shapes.

I assume this will fix #120.

Author: kastermester

src/TypeScriptGenerator.ts

@@ -61,6 +61,7 @@ function nullthrows<T>(obj: T | null | undefined): T {
 function makeProp(
   selection: Selection,
   state: State,
+  unmasked: boolean,
   concreteType?: string
 ): ts.PropertySignature {
   let { value } = selection;
@@ -69,7 +70,11 @@ function makeProp(
     value = transformScalarType(
       nodeType,
       state,
-      selectionsToAST([Array.from(nullthrows(nodeSelections).values())], state)
+      selectionsToAST(
+        [Array.from(nullthrows(nodeSelections).values())],
+        state,
+        unmasked
+      )
     );
   }
   if (schemaName === "__typename" && concreteType) {
@@ -88,6 +93,7 @@ const onlySelectsTypename = (selections: Selection[]) =>
 function selectionsToAST(
   selections: Selection[][],
   state: State,
+  unmasked: boolean,
   refTypeName?: string
 ): ts.TypeNode {
   const baseFields = new Map<string, Selection>();
@@ -109,77 +115,95 @@ 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 (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"))
-    );
-    const otherPropWithComment = ts.addSyntheticLeadingComment(
-      otherProp,
-      ts.SyntaxKind.MultiLineCommentTrivia,
-      "This will never be '% other', but we need some\n" +
-        "value in case none of the concrete values match.",
-      true
-    );
-    types.push([otherPropWithComment]);
-  }
+  if (
+    Object.keys(byConcreteType).length > 0 &&
+    onlySelectsTypename(Array.from(baseFields.values())) &&
+    (hasTypenameSelection(Array.from(baseFields.values())) ||
+      Object.keys(byConcreteType).every(type =>
+        hasTypenameSelection(byConcreteType[type])
+      ))
+  ) {
+    const typenameAliases = new Set<string>();
+    for (const concreteType in byConcreteType) {
+      types.push(
+        groupRefs([
+          ...Array.from(baseFields.values()),
+          ...byConcreteType[concreteType]
+        ]).map(selection => {
+          if (selection.schemaName === "__typename") {
+            typenameAliases.add(selection.key);
+          }
+          return makeProp(selection, state, unmasked, concreteType);
+        })
+      );
+    }
 
-  let selectionMap = selectionsToMap(Array.from(baseFields.values()));
-  for (const concreteType in byConcreteType) {
-    selectionMap = mergeSelections(
-      selectionMap,
-      selectionsToMap(
-        byConcreteType[concreteType].map(sel => ({
-          ...sel,
-          conditional: true
-        }))
-      )
+    types.push(
+      Array.from(typenameAliases).map(typenameAlias => {
+        const otherProp = readOnlyObjectTypeProperty(
+          typenameAlias,
+          ts.createLiteralTypeNode(ts.createLiteral("%other"))
+        );
+        const otherPropWithComment = ts.addSyntheticLeadingComment(
+          otherProp,
+          ts.SyntaxKind.MultiLineCommentTrivia,
+          "This will never be '%other', but we need some\n" +
+            "value in case none of the concrete values match.",
+          true
+        );
+        return otherPropWithComment;
+      })
     );
-  }
-  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)
-      )
+  } 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,
+              unmasked,
+              sel.concreteType
+            )
+          : makeProp(sel, state, unmasked)
     );
+    types.push(selectionMapValues);
   }
 
-  if (types.length > 0) {
-    const unionType = ts.createUnionTypeNode(
-      types.map(props => {
-        return exactObjectTypeAnnotation(props);
-      })
-    );
-    return ts.createIntersectionTypeNode([
-      exactObjectTypeAnnotation(baseProps),
-      unionType
-    ]);
-  } else {
-    return exactObjectTypeAnnotation(baseProps);
+  const typeElements = types.map(props => {
+    if (refTypeName) {
+      props.push(
+        readOnlyObjectTypeProperty(
+          REF_TYPE,
+          ts.createTypeReferenceNode(
+            ts.createIdentifier(refTypeName),
+            undefined
+          )
+        )
+      );
+    }
+    return unmasked
+      ? ts.createTypeLiteralNode(props)
+      : exactObjectTypeAnnotation(props);
+  });
+  if (typeElements.length === 1) {
+    return typeElements[0];
   }
+  return ts.createUnionTypeNode(typeElements);
 }
 
 // We don't have exact object types in typescript.
@@ -290,7 +314,7 @@ function createVisitor(options: TypeGeneratorOptions) {
         const inputObjectTypes = generateInputObjectTypes(state);
         const responseType = exportType(
           `${node.name}Response`,
-          selectionsToAST(node.selections, state)
+          selectionsToAST(node.selections, state, false)
         );
         const operationType = exportType(
           node.name,
@@ -368,7 +392,13 @@ function createVisitor(options: TypeGeneratorOptions) {
           );
           refTypeNodes.push(refType);
         }
-        const baseType = selectionsToAST(selections, state, refTypeName);
+        const unmasked = node.metadata != null && node.metadata.mask === false;
+        const baseType = selectionsToAST(
+          selections,
+          state,
+          unmasked,
+          refTypeName
+        );
         const type = isPlural(node)
           ? ts.createTypeReferenceNode(ts.createIdentifier("ReadonlyArray"), [
               baseType