fix: correctly type response when there is a 204 in addition to another 2xx response

Author: Gregory Haddow

plugins/typescript/src/core/getDataResponseType.test.ts

@@ -30,7 +30,7 @@ describe("getDataResponseType", () => {
       },
     };
 
-    const responseType = getDataResponseType({
+    const [responseType] = getDataResponseType({
       responses,
       printNodes: (nodes) => nodes.map(print).join("\n"),
     });
@@ -68,7 +68,7 @@ describe("getDataResponseType", () => {
       },
     };
 
-    const responseType = getDataResponseType({
+    const [responseType] = getDataResponseType({
       responses,
       printNodes: (nodes) => nodes.map(print).join("\n"),
     });
@@ -106,7 +106,7 @@ describe("getDataResponseType", () => {
       },
     };
 
-    const responseType = getDataResponseType({
+    const [responseType] = getDataResponseType({
       responses,
       printNodes: (nodes) => nodes.map(print).join("\n"),
     });
@@ -119,11 +119,39 @@ describe("getDataResponseType", () => {
   it("should returns undefined when no response", () => {
     const responses: ResponsesObject = {};
 
-    const responseType = getDataResponseType({
+    const [responseType] = getDataResponseType({
       responses,
       printNodes: (nodes) => nodes.map(print).join("\n"),
     });
 
     expect(print(responseType)).toMatchInlineSnapshot(`"undefined"`);
   });
+
+  it("should union undefined when also a 204 response", () => {
+    const responses: ResponsesObject = {
+      "200": {
+        description: "pet response",
+        content: {
+          "application/json": {
+            schema: {
+              type: "array",
+              items: {
+                $ref: "#/components/schemas/Pet",
+              },
+            },
+          },
+        },
+      },
+      "204": {
+        description: "no content",
+      },
+    };
+
+    const [responseType, has204] = getDataResponseType({
+      responses,
+      printNodes: (nodes) => nodes.map(print).join("\n"),
+    });
+    expect(has204).toBe(true);
+    expect(print(responseType)).toMatchInlineSnapshot(`"Schemas.Pet[]"`);
+  });
 });

plugins/typescript/src/core/getDataResponseType.ts

@@ -23,17 +23,24 @@ export const getDataResponseType = ({
   responses?: ResponsesObject;
   components?: ComponentsObject;
   printNodes: (nodes: ts.Node[]) => string;
-}) => {
+}): [ts.TypeNode, boolean] => {
   if (responses === undefined) {
-    return f.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword);
+    return [f.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword), false];
   }
+  let has204 = false;
   const responseTypes = uniqBy(
     Object.entries(responses).reduce(
       (
         mem,
         [statusCode, response]: [string, ResponseObject | ReferenceObject],
       ) => {
         if (!statusCode.startsWith("2")) return mem;
+
+        if (statusCode === "204") {
+          has204 = true;
+          return mem;
+        }
+
         if (isReferenceObject(response)) {
           const [hash, topLevel, namespace, name] = response.$ref.split("/");
           if (hash !== "#" || topLevel !== "components") {
@@ -74,9 +81,11 @@ export const getDataResponseType = ({
     (node) => printNodes([node]),
   );
 
-  return responseTypes.length === 0
-    ? f.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword)
-    : responseTypes.length === 1
-      ? responseTypes[0]
-      : f.createUnionTypeNode(responseTypes);
+  const responseType =
+    responseTypes.length === 0
+      ? f.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword)
+      : responseTypes.length === 1
+        ? responseTypes[0]
+        : f.createUnionTypeNode(responseTypes);
+  return [responseType, has204 && responseTypes.length > 0];
 };

plugins/typescript/src/core/getOperationTypes.ts

@@ -51,11 +51,13 @@ export const getOperationTypes = ({
   const declarationNodes: ts.Node[] = [];
 
   // Retrieve dataType
-  let dataType = getDataResponseType({
+  const dataTypeTuple = getDataResponseType({
     responses: operation.responses,
     components: openAPIDocument.components,
     printNodes,
   });
+  let dataType = dataTypeTuple[0];
+  const has204 = dataTypeTuple[1];
 
   // Retrieve errorType
   let errorType = getErrorResponseType({
@@ -159,6 +161,18 @@ export const getOperationTypes = ({
     dataType = f.createTypeReferenceNode(dataTypeIdentifier);
   }
 
+  if (has204) {
+    dataType = ts.isUnionTypeNode(dataType)
+      ? f.createUnionTypeNode([
+          ...dataType.types,
+          f.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword),
+        ])
+      : f.createUnionTypeNode([
+          dataType,
+          f.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword),
+        ]);
+  }
+
   // Export requestBody type if needed
   if (shouldExtractNode(requestBodyType)) {
     const requestBodyIdentifier = pascal(`${operationId}RequestBody`);