Refactoring Exception (line#739)

## PR Context
This PR is based on Issue line#699 to `Refactoring exception(Error class)`

## Need Feedbacks

### 1. unused Field (originalError)
```ts
export class RequestError extends Error {
  public code: string;

  private originalError: Error; // ⛳️ Not used private field

  constructor(message: Message, { code, originalError }: AxiosErrorDetails) {
    super(message);
    this.name = this.constructor.name;

    Object.assign(this, { code, originalError });
  }
}
```

`RequestError`'s originalError is a private field, but it is not being
used.
Looking at the commit history, it seems that there are cases where the
originalError field that was private is converted to public. I need
feedback whether to keep or remove the field. (It doesn't matter if you
keep the current code, but if you think you don't need it, we will
remove it.)

### 2. CodeConvention

In the process of improving the class, there was no information on the
code convention, so we applied Airbnb's code convention (such as
applying the extension to the class member variable) lightly.
However, if you believe that excessive modification rather harms
readability, I will remove all modifications. Please feedback on this as
well!

```ts
export class HTTPFetchError extends Error {
  public status: number;

  public statusText: string;

  public headers: Headers;

  public body: string;

  constructor(
    message: Message,
    { status, statusText, headers, body }: FetchErrorDetails,
  ) {
    super(message);
    this.name = this.constructor.name;

    Object.assign(this, { status, statusText, headers, body });
  }
}
```

### 3. Interface

I tried to declare all the attributes of each error inside one
interface, but I removed the interface. If you think it is excessive, I
will manage it on one interface. :)
```ts
type Message = string;

interface Status {
  status: number;
  statusText: string;
}

interface ErrorDetails {
  signature?: string;
  raw?: any;
}

interface FetchErrorDetails extends Status {
  headers: Headers;
  body: string;
}

// Deprecated
interface AxiosErrorDetails extends Partial<Status> {
  originalError: Error;
  code?: string;
}
```
---

After reviewing the code, I would appreciate it if you could discuss the
direction of the code and request further changes.

Author: pengooseDev

docs/guide/client.md

@@ -111,7 +111,7 @@ client
    })
   .catch((err) => {
     if (err instanceof HTTPFetchError) {
-      console.error(err.statusCode);
+      console.error(err.status);
       console.error(err.headers.get('x-line-request-id'));
       console.error(err.body);
     }

examples/echo-bot-ts/index.ts

@@ -82,7 +82,7 @@ app.post(
           await textEventHandler(event);
         } catch (err: unknown) {
           if (err instanceof HTTPFetchError) {
-            console.error(err.statusCode);
+            console.error(err.status);
             console.error(err.headers.get('x-line-request-id'));
             console.error(err.body);
           } else if (err instanceof Error) {

lib/exceptions.ts

@@ -1,55 +1,109 @@
+type Message = string;
+
+interface Status {
+  status: number;
+  statusText: string;
+}
+
+interface ErrorDetails {
+  signature?: string;
+  raw?: any;
+}
+
+interface FetchErrorDetails extends Status {
+  headers: Headers;
+  body: string;
+}
+
+// Deprecated
+interface AxiosErrorDetails {
+  originalError: Error;
+  code?: string;
+  statusCode?: number;
+  statusMessage?: string;
+}
+
 export class SignatureValidationFailed extends Error {
-  constructor(
-    message: string,
-    public signature?: string,
-  ) {
+  public signature?: string;
+
+  constructor(message: Message, { signature }: ErrorDetails = {}) {
     super(message);
+    this.name = this.constructor.name;
+
+    Object.assign(this, { signature });
   }
 }
 
 export class JSONParseError extends Error {
-  constructor(
-    message: string,
-    public raw: any,
-  ) {
+  public raw: any;
+
+  constructor(message: Message, { raw }: ErrorDetails = {}) {
     super(message);
+    this.name = this.constructor.name;
+
+    Object.assign(this, { raw });
   }
 }
 
+/* Deprecated */
 export class RequestError extends Error {
-  constructor(
-    message: string,
-    public code: string,
-    private originalError: Error,
-  ) {
+  public code: string;
+
+  private originalError: Error;
+
+  constructor(message: Message, { code, originalError }: AxiosErrorDetails) {
     super(message);
+    this.name = this.constructor.name;
+
+    Object.assign(this, { code, originalError });
   }
 }
 
 export class ReadError extends Error {
-  constructor(private originalError: Error) {
-    super(originalError.message);
+  public originalError: Error;
+
+  constructor(message: Message, { originalError }: AxiosErrorDetails) {
+    super(message);
+    this.name = this.constructor.name;
+
+    Object.assign(this, { originalError });
   }
 }
 
 export class HTTPError extends Error {
+  public statusCode: number;
+
+  public statusMessage: string;
+
+  public originalError: any;
+
   constructor(
-    message: string,
-    public statusCode: number,
-    public statusMessage: string,
-    public originalError: any,
+    message: Message,
+    { statusCode, statusMessage, originalError }: AxiosErrorDetails,
   ) {
     super(message);
+    this.name = this.constructor.name;
+
+    Object.assign(this, { statusCode, statusMessage, originalError });
   }
 }
 
 export class HTTPFetchError extends Error {
+  public status: number;
+
+  public statusText: string;
+
+  public headers: Headers;
+
+  public body: string;
+
   constructor(
-    public statusCode: number,
-    public statusMessage: string,
-    public headers: Headers,
-    public body: string,
+    message: Message,
+    { status, statusText, headers, body }: FetchErrorDetails,
   ) {
-    super(`${statusCode} - ${statusMessage}`);
+    super(message);
+    this.name = this.constructor.name;
+
+    Object.assign(this, { status, statusText, headers, body });
   }
 }

lib/http-axios.ts

@@ -164,17 +164,22 @@ export default class HTTPClient {
 
   private wrapError(err: AxiosError): Error {
     if (err.response) {
-      return new HTTPError(
-        err.message,
-        err.response.status,
-        err.response.statusText,
-        err,
-      );
+      const { status, statusText } = err.response;
+      const { message } = err;
+
+      return new HTTPError(message, {
+        statusCode: status,
+        statusMessage: statusText,
+        originalError: err,
+      });
     } else if (err.code) {
-      return new RequestError(err.message, err.code, err);
+      const { message, code } = err;
+      return new RequestError(message, { code, originalError: err });
     } else if (err.config) {
       // unknown, but from axios
-      return new ReadError(err);
+      const { message } = err;
+
+      return new ReadError(message, { originalError: err });
     }
 
     // otherwise, just rethrow

lib/http-fetch.ts

@@ -165,13 +165,18 @@ export default class HTTPFetchClient {
   }
 
   private async checkResponseStatus(response: Response) {
-    if (!response.ok) {
-      throw new HTTPFetchError(
-        response.status,
-        response.statusText,
-        response.headers,
-        await response.text(),
-      );
+    const { ok, status, statusText, headers } = response;
+    const message = `${status} - ${statusText}`;
+
+    if (!ok) {
+      const body = await response.text();
+
+      throw new HTTPFetchError(message, {
+        status,
+        statusText,
+        headers,
+        body,
+      });
     }
   }
 }

lib/middleware.ts

@@ -55,7 +55,9 @@ export default function middleware(config: Types.MiddlewareConfig): Middleware {
 
     if (!validateSignature(body, secret, signature)) {
       next(
-        new SignatureValidationFailed("signature validation failed", signature),
+        new SignatureValidationFailed("signature validation failed", {
+          signature,
+        }),
       );
       return;
     }
@@ -66,7 +68,9 @@ export default function middleware(config: Types.MiddlewareConfig): Middleware {
       req.body = JSON.parse(strBody);
       next();
     } catch (err) {
-      next(new JSONParseError(err.message, strBody));
+      const { message } = err;
+
+      next(new JSONParseError(message, { raw: strBody }));
     }
   };
   return (req, res, next): void => {

lib/utils.ts

@@ -8,7 +8,7 @@ export function ensureJSON<T>(raw: T): T {
   if (typeof raw === "object") {
     return raw;
   } else {
-    throw new JSONParseError("Failed to parse response body as JSON", raw);
+    throw new JSONParseError("Failed to parse response body as JSON", { raw });
   }
 }
 

test/helpers/test-server.ts

@@ -9,7 +9,7 @@ import {
 } from "../../lib/exceptions";
 import * as finalhandler from "finalhandler";
 
-let server: Server = null;
+let server: Server | null = null;
 
 function listen(port: number, middleware?: express.RequestHandler) {
   const app = express();
@@ -83,8 +83,9 @@ function listen(port: number, middleware?: express.RequestHandler) {
 function close() {
   return new Promise(resolve => {
     if (!server) {
-      resolve(undefined);
+      return resolve(undefined);
     }
+
     server.close(() => resolve(undefined));
   });
 }

test/http-fetch.spec.ts

@@ -217,7 +217,7 @@ describe("http(fetch)", () => {
     } catch (err) {
       ok(err instanceof HTTPFetchError);
       equal(scope.isDone(), true);
-      equal(err.statusCode, 404);
+      equal(err.status, 404);
       equal(err.headers.get("content-type"), "application/json");
       equal(err.body, '{"reason":"not found"}');
     }

tsconfig.json

@@ -5,9 +5,9 @@
     "noImplicitAny": true,
     "outDir": "dist",
     "rootDirs": ["lib", "test"],
-    "declaration": true
+    "declaration": true,
   },
   "include": [
-    "lib/**/*.ts"
+    "lib/**/*.ts",
   ]
 }