feat!: Improve error type safety (#63)

* Add getErrorResponseType

* Extract getDataResponseType

* Use new response types

* Add test to getUsedImports

* Extract testUtils

* Fix template.test.ts type issues

* Add createNamespaceImport helper

* Generate new error format

* Generate utils

* Inject TError

* Export allError type

* Generate utils file

* Tweak fetcher template

* Remove all errors export

* Improve fallback error

* Generate utils only when needed

* Ensure error format in every situation

Author: fabien0102

plugins/typescript/src/core/createNamespaceImport.ts

@@ -0,0 +1,21 @@
+import { factory as f } from "typescript";
+
+/**
+ * Helper to create namespace import.
+ *
+ * @param namespace namespace import identifier
+ * @param filename path of the module
+ * @returns ts.Node of the import declaration
+ */
+export const createNamespaceImport = (namespace: string, filename: string) =>
+  f.createImportDeclaration(
+    undefined,
+    undefined,
+    f.createImportClause(
+      true,
+      undefined,
+      f.createNamespaceImport(f.createIdentifier(namespace))
+    ),
+    f.createStringLiteral(filename),
+    undefined
+  );

plugins/typescript/src/core/createOperationFetcherFnNodes.ts

@@ -9,6 +9,7 @@ import ts, { factory as f } from "typescript";
  */
 export const createOperationFetcherFnNodes = ({
   dataType,
+  errorType,
   requestBodyType,
   queryParamsType,
   pathParamsType,
@@ -21,6 +22,7 @@ export const createOperationFetcherFnNodes = ({
   name,
 }: {
   dataType: ts.TypeNode;
+  errorType: ts.TypeNode;
   requestBodyType: ts.TypeNode;
   headersType: ts.TypeNode;
   pathParamsType: ts.TypeNode;
@@ -68,6 +70,7 @@ export const createOperationFetcherFnNodes = ({
                 f.createIdentifier(fetcherFn),
                 [
                   dataType,
+                  errorType,
                   requestBodyType,
                   headersType,
                   queryParamsType,

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

@@ -0,0 +1,129 @@
+import { ResponsesObject } from "openapi3-ts";
+import { print } from "../testUtils";
+import { getDataResponseType } from "./getDataResponseType";
+
+describe("getDataResponseType", () => {
+  it("should extract the response type with 200 status", () => {
+    const responses: ResponsesObject = {
+      "200": {
+        description: "pet response",
+        content: {
+          "application/json": {
+            schema: {
+              type: "array",
+              items: {
+                $ref: "#/components/schemas/Pet",
+              },
+            },
+          },
+        },
+      },
+      default: {
+        description: "unexpected error",
+        content: {
+          "application/json": {
+            schema: {
+              $ref: "#/components/schemas/Error",
+            },
+          },
+        },
+      },
+    };
+
+    const responseType = getDataResponseType({
+      responses,
+      printNodes: (nodes) => nodes.map(print).join("\n"),
+    });
+
+    expect(print(responseType)).toMatchInlineSnapshot(`"Schemas.Pet[]"`);
+  });
+
+  it("should remove duplicate responses", () => {
+    const responses: ResponsesObject = {
+      "200": {
+        description: "pet response",
+        content: {
+          "application/json": {
+            schema: {
+              type: "array",
+              items: {
+                $ref: "#/components/schemas/Pet",
+              },
+            },
+          },
+        },
+      },
+      "203": {
+        description: "pet response",
+        content: {
+          "application/json": {
+            schema: {
+              type: "array",
+              items: {
+                $ref: "#/components/schemas/Pet",
+              },
+            },
+          },
+        },
+      },
+    };
+
+    const responseType = getDataResponseType({
+      responses,
+      printNodes: (nodes) => nodes.map(print).join("\n"),
+    });
+
+    expect(print(responseType)).toMatchInlineSnapshot(`"Schemas.Pet[]"`);
+  });
+
+  it("should create a union", () => {
+    const responses: ResponsesObject = {
+      "200": {
+        description: "pet response",
+        content: {
+          "application/json": {
+            schema: {
+              type: "array",
+              items: {
+                $ref: "#/components/schemas/Pet",
+              },
+            },
+          },
+        },
+      },
+      "203": {
+        description: "pet response",
+        content: {
+          "application/json": {
+            schema: {
+              type: "array",
+              items: {
+                $ref: "#/components/schemas/Cat",
+              },
+            },
+          },
+        },
+      },
+    };
+
+    const responseType = getDataResponseType({
+      responses,
+      printNodes: (nodes) => nodes.map(print).join("\n"),
+    });
+
+    expect(print(responseType)).toMatchInlineSnapshot(
+      `"Schemas.Pet[] | Schemas.Cat[]"`
+    );
+  });
+
+  it("should returns undefined when no response", () => {
+    const responses: ResponsesObject = {};
+
+    const responseType = getDataResponseType({
+      responses,
+      printNodes: (nodes) => nodes.map(print).join("\n"),
+    });
+
+    expect(print(responseType)).toMatchInlineSnapshot(`"undefined"`);
+  });
+});

…s/typescript/src/core/getResponseType.ts …pescript/src/core/getDataResponseType.tsplugins/typescript/src/core/getResponseType.ts renamed to plugins/typescript/src/core/getDataResponseType.ts plugins/typescript/src/core/getResponseType.ts renamed to plugins/typescript/src/core/getDataResponseType.ts

@@ -13,17 +13,15 @@ import { findCompatibleMediaType } from "./findCompatibleMediaType";
 import { getType } from "./schemaToTypeAliasDeclaration";
 
 /**
- * Extract types from responses
+ * Extract types from success responses (2xx)
  */
-export const getResponseType = ({
+export const getDataResponseType = ({
   responses,
   components,
-  filter,
   printNodes,
 }: {
   responses: ResponsesObject;
   components?: ComponentsObject;
-  filter: (statusCode: string) => boolean;
   printNodes: (nodes: ts.Node[]) => string;
 }) => {
   const responseTypes = uniqBy(
@@ -32,7 +30,7 @@ export const getResponseType = ({
         mem,
         [statusCode, response]: [string, ResponseObject | ReferenceObject]
       ) => {
-        if (!filter(statusCode)) return mem;
+        if (!statusCode.startsWith("2")) return mem;
         if (isReferenceObject(response)) {
           const [hash, topLevel, namespace, name] = response.$ref.split("/");
           if (hash !== "#" || topLevel !== "components") {