clean: Use node-fetch instead of deprecated request

Author: rtfpessoa

package.json

@@ -81,16 +81,18 @@
     ]
   },
   "dependencies": {
-    "clipboardy": "^2.2.0",
-    "diff2html": "3.1.6",
-    "open": "^7.0.3",
-    "request": "^2.88.2",
-    "yargs": "^15.3.0"
+    "clipboardy": "^2.1.0",
+    "diff2html": "3.0.0",
+    "node-fetch": "^2.6.0",
+    "open": "^7.0.2",
+    "request": "^2.88.0",
+    "yargs": "^15.0.2"
   },
   "devDependencies": {
     "@types/hogan.js": "^3.0.0",
-    "@types/jest": "25.1.4",
-    "@types/node": "13.9.1",
+    "@types/jest": "25.1.1",
+    "@types/node": "13.7.0",
+    "@types/node-fetch": "^2.5.6",
     "@types/request": "2.48.4",
     "@typescript-eslint/eslint-plugin": "2.23.0",
     "@typescript-eslint/parser": "2.23.0",

src/cli.ts

@@ -102,8 +102,30 @@ export function preview(content: string, format: string): void {
   open(filePath, { wait: false });
 }
 
+type CreateDiffResponse = { id: string };
+
+type ApiError = { error: string };
+
+function isCreateDiffResponse(obj: unknown): obj is CreateDiffResponse {
+  return (obj as CreateDiffResponse).id !== undefined;
+}
+
+function isApiError(obj: unknown): obj is ApiError {
+  return (obj as ApiError).error !== undefined;
+}
+
 export async function postToDiffy(diff: string, diffyOutput: DiffyType): Promise<string> {
-  const response = await http.put<{ id: string }>('https://diffy.org/api/diff/', { diff: diff });
+  const response = await http.put('https://diffy.org/api/diff/', { diff: diff });
+
+  if (!isCreateDiffResponse(response)) {
+    if (isApiError(response)) {
+      throw new Error(response.error);
+    } else {
+      throw new Error(
+        `Could not find 'id' of created diff in the response json.\nBody:\n\n${JSON.stringify(response, null, 2)}`,
+      );
+    }
+  }
 
   const url = `https://diffy.org/diff/${response.id}`;
 

src/http-utils.ts

@@ -1,36 +1,23 @@
-import request from 'request';
+import fetch from 'node-fetch';
 
-export function put<T extends object>(url: string, payload: object): Promise<T> {
-  return new Promise<T>((resolve, reject): void => {
-    request({
-      url: url,
-      method: 'PUT',
-      headers: {},
-      body: payload,
-      json: true,
-    })
-      .on('response', response => {
-        response.on('data', body => {
-          try {
-            const jsonObj = JSON.parse(body.toString('utf8'));
-            if (jsonObj as T) {
-              return resolve(jsonObj);
-            } else if (jsonObj.error !== undefined && typeof jsonObj.error === 'string') {
-              return reject(new Error(jsonObj.error));
-            } else {
-              return reject(
-                new Error(
-                  `Failed to read response.
-                Body:
-                ${body.toString('utf8')}`,
-                ),
-              );
-            }
-          } catch (err) {
-            return reject(err);
-          }
-        });
-      })
-      .on('error', err => reject(err));
+export function put(url: string, payload: object): Promise<unknown> {
+  return fetch(url, {
+    method: 'PUT',
+    headers: {
+      Accept: 'application/json',
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify(payload),
+  }).then(async response => {
+    const bodyText = await response.text();
+    try {
+      return JSON.parse(bodyText);
+    } catch (error) {
+      if (error instanceof SyntaxError) {
+        throw new Error(`Failed to parse response json.\nBody:\n\n${bodyText}`);
+      } else {
+        throw error;
+      }
+    }
   });
 }