Replace got with axios

Author: Hyunje Jun

lib/client.ts

@@ -46,7 +46,7 @@ export default class Client {
     return this.get(URL.roomMemberProfile(roomId, userId));
   }
 
-  public getMessageContent(messageId: string): NodeJS.ReadableStream {
+  public getMessageContent(messageId: string): Promise<NodeJS.ReadableStream> {
     return this.stream(URL.content(messageId));
   }
 
@@ -70,7 +70,7 @@ export default class Client {
     return post(url, this.authHeader(), body);
   }
 
-  private stream(url: string): NodeJS.ReadableStream {
+  private stream(url: string): Promise<NodeJS.ReadableStream> {
     return stream(url, this.authHeader());
   }
 }

lib/exceptions.ts

@@ -1,52 +1,46 @@
-import * as got from "got";
-
 export class SignatureValidationFailed extends Error {
-  public signature: string;
-
-  constructor(msg: string, signature: string) {
-    super(msg);
-    this.signature = signature;
+  constructor(
+    message: string,
+    public signature: string,
+  ) {
+    super(message);
   }
 }
 
 export class JSONParseError extends Error {
-  public raw: string;
-
-  constructor(msg: string, raw: string) {
-    super(msg);
-    this.raw = raw;
+  constructor(
+    message: string,
+    public raw: any,
+  ) {
+    super(message);
   }
 }
 
 export class RequestError extends Error {
-  public code: string;
-  private origin: Error;
-
-  constructor(gotErr: RequestError) {
-    super(gotErr.message);
-    this.code = gotErr.code;
-    this.origin = gotErr;
+  constructor(
+    message: string,
+    public code: string,
+    private originalError: Error,
+  ) {
+    super(message);
   }
 }
 
 export class ReadError extends Error {
-  private origin: Error;
-
-  constructor(gotErr: ReadError) {
-    super(gotErr.message);
-    this.origin = gotErr;
+  constructor(
+    private originalError: Error,
+  ) {
+    super(originalError.message);
   }
 }
 
 export class HTTPError extends Error {
-  public statusCode: number;
-  public statusMessage: string;
-  private origin: Error;
-
-  constructor(gotErr: HTTPError) {
-    super(gotErr.message);
-    this.statusCode = gotErr.statusCode;
-    this.statusMessage = gotErr.statusMessage;
-    this.origin = gotErr;
+  constructor(
+    message: string,
+    public statusCode: number,
+    public statusMessage: string,
+    private originalError: Error,
+  ) {
+    super(message);
   }
 }

lib/http.ts

@@ -1,4 +1,4 @@
-import * as got from "got";
+import axios, { AxiosError } from "axios";
 import {
   HTTPError,
   JSONParseError,
@@ -8,21 +8,31 @@ import {
 
 const pkg = require("../package.json"); // tslint:disable-line no-var-requires
 
-function parseJSON(raw: string): any {
-  try {
-    return JSON.parse(raw);
-  } catch (err) {
-    throw new JSONParseError(err.message, raw);
+function checkJSON(raw: any): any {
+  if (typeof raw === "object") {
+    return raw;
+  } else {
+    throw new JSONParseError("Failed to parse response body as JSON", raw);
   }
 }
 
-function wrapError(err: Error) {
-  if (err instanceof got.RequestError) {
-    throw new RequestError(err as any);
-  } else if (err instanceof got.ReadError) {
-    throw new ReadError(err as any);
-  } else if (err instanceof got.HTTPError) {
-    throw new HTTPError(err as any);
+function wrapError(err: AxiosError) {
+  if (err.response) {
+    throw new HTTPError(
+      err.message,
+      err.response.status,
+      err.response.statusText,
+      err,
+    );
+  } else if (err.code) {
+    throw new RequestError(
+      err.message,
+      err.code,
+      err,
+    );
+  } else if (err.config) {
+    // unknown, but from axios
+    throw new ReadError(err);
   }
 
   // otherwise, just rethrow
@@ -31,27 +41,27 @@ function wrapError(err: Error) {
 
 const userAgent = `${pkg.name}/${pkg.version}`;
 
-export function stream(url: string, headers: any): NodeJS.ReadableStream {
+export function stream(url: string, headers: any): Promise<NodeJS.ReadableStream> {
   headers["User-Agent"] = userAgent;
-  return got.stream(url, { headers });
+  return axios
+    .get(url, { headers, responseType: "stream" })
+    .then((res) => res.data as NodeJS.ReadableStream);
 }
 
 export function get(url: string, headers: any): Promise<any> {
   headers["User-Agent"] = userAgent;
-  return got
+
+  return axios
     .get(url, { headers })
-    .then((res: any) => parseJSON(res.body))
+    .then((res) => checkJSON(res.data))
     .catch(wrapError);
 }
 
-export function post(url: string, headers: any, body?: any): Promise<any> {
+export function post(url: string, headers: any, data?: any): Promise<any> {
   headers["Content-Type"] = "application/json";
   headers["User-Agent"] = userAgent;
-  return got
-    .post(url, {
-      body: JSON.stringify(body),
-      headers,
-    })
-    .then((res: any) => parseJSON(res.body))
+  return axios
+    .post(url, data, { headers })
+    .then((res) => checkJSON(res.data))
     .catch(wrapError);
 }

test/client.spec.ts

@@ -78,8 +78,8 @@ describe("client", () => {
   });
 
   it("getMessageContent", () => {
-    const s = client.getMessageContent("test_message_id");
-    return getStreamData(s)
+    return client.getMessageContent("test_message_id")
+      .then((s) => getStreamData(s))
       .then((data) => {
         const res = JSON.parse(data);
         equal(res.headers.authorization, "Bearer test_channel_access_token");

test/http.spec.ts

@@ -71,8 +71,8 @@ describe("http", () => {
       "test-header-key": "Test-Header-Value",
     };
 
-    const s = stream(`${TEST_URL}/stream.txt`, testHeaders);
-    return getStreamData(s)
+    return stream(`${TEST_URL}/stream.txt`, testHeaders)
+      .then((s) => getStreamData(s))
       .then((result) => {
         equal(result, "hello, stream!\n");
       });

test/middleware.spec.ts

@@ -65,7 +65,7 @@ describe("middleware", () => {
   });
 
   it("fails on invalid JSON", () => {
-    const auth: any = { "X-Line-Signature": "EqtMVtbumD+AWcprLA6Ty/KsHAN910X7x9EogZkXRHU=" };
+    const auth: any = { "X-Line-Signature": "Z8YlPpm0lQOqPipiCHVbiuwIDIzRzD7w5hvHgmwEuEs=" };
 
     return post(`${TEST_URL}/webhook`, auth, "i am not jason")
       .catch((err: HTTPError) => {