fix(deps): update dependency typescript to v4.4.2 (#1192)

* fix(deps): update dependency typescript to v4.4.2

* Introduce asError and fs.promises

* Fixed tests I think

Co-authored-by: Renovate Bot <bot@renovateapp.com>
Co-authored-by: Josh Goldberg <me@joshuakgoldberg.com>

Author: 3 people

package-lock.json

@@ -19,7 +19,7 @@
         "lodash": "4.17.21",
         "minimatch": "3.0.4",
         "tslint": "6.1.3",
-        "typescript": "4.3.5"
+        "typescript": "4.4.2"
     },
     "devDependencies": {
         "@babel/core": "7.15.0",

package.json

@@ -7,4 +7,4 @@ export const createStubExec = ({ stderr = "", stdout = "" } = {}) =>
     jest.fn().mockReturnValue(Promise.resolve({ stderr, stdout }));
 
 export const createStubThrowingExec = ({ stderr = "" } = {}) =>
-    jest.fn().mockRejectedValue(Promise.resolve(new Error(stderr)));
+    jest.fn().mockRejectedValue(new Error(stderr));

src/adapters/exec.stubs.ts

@@ -1,31 +1,29 @@
 import * as fs from "fs";
-import { promisify } from "util";
 
+import { asError } from "../utils";
 import { FileSystem } from "./fileSystem";
 
-const readFile = promisify(fs.readFile);
-const writeFile = promisify(fs.writeFile);
-
 export const fsFileSystem: FileSystem = {
     fileExists: async (filePath: string) => {
         try {
             return fs.existsSync(filePath);
-        } catch (error) {
+        } catch {
             return false;
         }
     },
     readFile: async (filePath: string) => {
         try {
-            return (await readFile(filePath)).toString();
+            return (await fs.promises.readFile(filePath)).toString();
         } catch (error) {
-            return error;
+            return asError(error);
         }
     },
     writeFile: async (filePath: string, contents: string) => {
         try {
-            return writeFile(filePath, contents);
+            await fs.promises.writeFile(filePath, contents);
+            return undefined;
         } catch (error) {
-            return error;
+            return asError(error);
         }
     },
 };

src/adapters/fsFileSystem.ts

@@ -3,6 +3,7 @@ import { EOL } from "os";
 import { processLogger } from "../adapters/processLogger";
 import { runCliDependencies } from "../api/dependencies";
 import { runCli } from "../cli/runCli";
+import { asError } from "../utils";
 
 export const main = async (argv: string[]) => {
     try {
@@ -14,7 +15,9 @@ export const main = async (argv: string[]) => {
         }
     } catch (error) {
         processLogger.info.close();
-        processLogger.stdout.write(`Error in tslint-to-eslint-config: ${error.stack}${EOL}`);
+        processLogger.stdout.write(
+            `Error in tslint-to-eslint-config: ${asError(error).stack}${EOL}`,
+        );
         process.exitCode = 1;
     }
 };

src/cli/main.ts

@@ -1,4 +1,5 @@
 import { SansDependencies } from "../binding";
+import { asError } from "../utils";
 import { importer } from "./importer";
 
 export const findRawConfiguration = async <Configuration>(
@@ -11,7 +12,7 @@ export const findRawConfiguration = async <Configuration>(
     try {
         results = (await fileImporter(filePath)) as Configuration;
     } catch (error) {
-        return error;
+        return asError(error);
     }
 
     return {

src/input/findRawConfiguration.ts

@@ -1,4 +1,5 @@
 import { Exec } from "../adapters/exec";
+import { asError } from "../utils";
 
 export type DeepPartial<T> = {
     [P in keyof T]?: T[P] extends Record<string, unknown> ? DeepPartial<T[P]> : T[P];
@@ -37,6 +38,6 @@ const execAndCatch = async (exec: Exec, fullCommand: string): Promise<string | E
 
         return stdout;
     } catch (error) {
-        return error;
+        return asError(error);
     }
 };

src/input/findReportedConfiguration.ts

@@ -1,4 +1,35 @@
-import { isDefined, isError, removeEmptyMembers, separateErrors, uniqueFromSources } from "./utils";
+import {
+    asError,
+    isDefined,
+    isError,
+    removeEmptyMembers,
+    separateErrors,
+    uniqueFromSources,
+} from "./utils";
+
+describe("asError", () => {
+    it("returns the input when the input is an error", () => {
+        // Arrange
+        const input = new Error("Oh no!");
+
+        // Act
+        const result = asError(input);
+
+        // Assert
+        expect(result).toBe(input);
+    });
+
+    it("returns an equivalent error when the input is not an error", () => {
+        // Arrange
+        const input = "Oh no!";
+
+        // Act
+        const result = asError(input);
+
+        // Assert
+        expect(result).toEqual(new Error(input));
+    });
+});
 
 describe("isDefined", () => {
     it("returns true when the item is defined", () => {

src/utils.test.ts

@@ -4,6 +4,8 @@ export type Entries<T> = {
     [K in keyof T]: [K, T[K]];
 }[keyof T][];
 
+export const asError = (error: unknown) => (error instanceof Error ? error : new Error(`${error}`));
+
 export const isDefined = <Item>(item: Item | undefined): item is Item => item !== undefined;
 
 export const isError = <Item>(item: Item | Error): item is Error => item instanceof Error;