fix(project): improve fault tolerance when reading package.json

djcsdy · djcsdy · commit cf3ad94844b7 · 2021-06-09T15:00:34.000+01:00
diff --git a/cli/update.ts b/cli/update.ts
@@ -2,22 +2,28 @@ import {exit} from "process";
 import chain from "@softwareventures/chain";
 import {forEachFn, mapFn} from "@softwareventures/array";
 import {readProject} from "../project/read";
-import {bindFailureFn} from "../result/result";
-import {updateProject} from "../project/update";
+import {bindAsyncResultFn, bindFailureFn} from "../result/result";
+import {UpdateFailureReason, updateProject} from "../project/update";
+import {ReadJsonFailureReason} from "../project/read-json";
+import {Project} from "../project/project";
 
 export function cliUpdate(path: string, options: object): void {
     readProject(path)
-        .then(updateProject)
+        .then(bindAsyncResultFn<ReadJsonFailureReason, UpdateFailureReason, Project>(updateProject))
         .then(
             bindFailureFn(reasons => {
                 chain(reasons)
                     .map(
                         mapFn(reason => {
                             switch (reason.type) {
+                                case "file-not-found":
+                                    return `File Not Found: ${reason.path}`;
                                 case "not-a-directory":
                                     return `Not a Directory: ${reason.path}`;
                                 case "file-exists":
                                     return `File Exists: ${reason.path}`;
+                                case "invalid-json":
+                                    return `Invalid JSON: ${reason.path}`;
                                 case "git-not-clean":
                                     return `Git working copy not clean: ${reason.path}`;
                                 case "yarn-fix-failed":
diff --git a/prettier/fix.ts b/prettier/fix.ts
@@ -1,8 +1,16 @@
 import {resolve} from "path";
 import {mapFn} from "@softwareventures/array";
+import {mapNullFn} from "@softwareventures/nullable";
 import {ProjectSource} from "../project/project";
 import {readProjectJson} from "../project/read-json";
-import {combineAsyncResults, mapFailureFn, Result, success} from "../result/result";
+import {
+    combineAsyncResults,
+    mapFailureFn,
+    mapResultFn,
+    Result,
+    success,
+    toNullable
+} from "../result/result";
 import {yarn} from "../yarn/yarn";
 
 export type PrettierFixResult = Result<PrettierFixFailureReason>;
@@ -43,17 +51,14 @@ export async function prettierFixFilesIfAvailable(
 
 export async function isPrettierAvailable(project: ProjectSource): Promise<boolean> {
     return readProjectJson(project, "package.json")
-        .catch(reason => {
-            if (reason instanceof SyntaxError || reason.code === "ENOENT") {
-                return false;
-            } else {
-                throw reason;
-            }
-        })
         .then(
-            packageJson =>
-                packageJsonDependsOnPrettier(packageJson) && yarnPrettierCanRun(packageJson)
-        );
+            mapResultFn(
+                packageJson =>
+                    packageJsonDependsOnPrettier(packageJson) && yarnPrettierCanRun(packageJson)
+            )
+        )
+        .then(toNullable)
+        .then(mapNullFn(() => false));
 }
 
 function packageJsonDependsOnPrettier(packageJson: any): boolean {
diff --git a/project/read-json.ts b/project/read-json.ts
@@ -1,6 +1,33 @@
+import {failure, Result, success} from "../result/result";
+import {FileNotFound} from "../fs-stage/file-not-found";
 import {ProjectSource} from "./project";
 import {readProjectText} from "./read-text";
 
-export async function readProjectJson(project: ProjectSource, path: string): Promise<any> {
-    return readProjectText(project, path).then(JSON.parse);
+export type ReadJsonResult = Result<ReadJsonFailureReason, any>;
+
+export type ReadJsonFailureReason = FileNotFound | InvalidJson;
+
+export interface InvalidJson {
+    readonly type: "invalid-json";
+    readonly path: string;
+}
+
+export async function readProjectJson(
+    project: ProjectSource,
+    path: string
+): Promise<ReadJsonResult> {
+    return readProjectText(project, path)
+        .then(JSON.parse)
+        .then(
+            json => success(json),
+            reason => {
+                if (reason.code === "ENOENT") {
+                    return failure([{type: "file-not-found", path}]);
+                } else if (reason instanceof SyntaxError) {
+                    return failure([{type: "invalid-json", path}]);
+                } else {
+                    throw reason;
+                }
+            }
+        );
 }
diff --git a/project/read.ts b/project/read.ts
@@ -5,23 +5,28 @@ import {mapNullableFn, mapNullFn} from "@softwareventures/nullable";
 import {gitHostFromUrl} from "../git/git-host";
 import {createNodeVersions} from "../node/create";
 import {parseAndCorrectSpdxExpression} from "../license/spdx/correct";
+import {allAsyncResults, mapResultFn, Result} from "../result/result";
 import {statProjectFile} from "./stat-file";
 import {Project} from "./project";
-import {readProjectJson} from "./read-json";
+import {ReadJsonFailureReason, readProjectJson} from "./read-json";
 
-export async function readProject(path: string): Promise<Project> {
+export type ReadProjectResult = Result<ReadJsonFailureReason, Project>;
+
+export async function readProject(path: string): Promise<ReadProjectResult> {
     path = resolve(path);
 
     const project = {path};
 
     const packageJson = readProjectJson(project, "package.json");
 
     const npmPackage = packageJson
-        .then(packageJson => packageJson.name ?? "")
-        .then(name => /^(?:(@.*?)\/)?(.*)$/.exec(name) ?? ["", "", ""])
-        .then(([_, scope, name]) => ({scope, name}));
+        .then(mapResultFn(packageJson => packageJson?.name ?? ""))
+        .then(mapResultFn(name => /^(?:(@.*?)\/)?(.*)$/.exec(name) ?? ["", "", ""]))
+        .then(mapResultFn(([_, scope, name]) => ({scope, name})));
 
-    const gitHost = packageJson.then(packageJson => packageJson.repository).then(gitHostFromUrl);
+    const gitHost = packageJson
+        .then(mapResultFn(packageJson => packageJson?.repository))
+        .then(mapResultFn(gitHostFromUrl));
 
     const target = statProjectFile(project, "webpack.config.js")
         .catch(reason => {
@@ -33,36 +38,45 @@ export async function readProject(path: string): Promise<Project> {
         })
         .then(stats => (stats?.isFile() ? "webapp" : "npm"));
 
-    const author = packageJson.then(({author}) =>
-        typeof author === "object"
-            ? {name: author.name, email: author.email}
-            : typeof author === "string"
-            ? chain(/^\s*(.*?)(?:\s+<\s*(.*)\s*>)?\s*$/.exec(author) ?? []).map(
-                  ([_, name, email]) => ({name, email})
-              ).value
-            : {}
-    );
+    const author = packageJson
+        .then(mapResultFn(packageJson => packageJson?.author))
+        .then(
+            mapResultFn(author =>
+                typeof author === "object"
+                    ? {name: author?.name, email: author?.email}
+                    : typeof author === "string"
+                    ? chain(/^\s*(.*?)(?:\s+<\s*(.*)\s*>)?\s*$/.exec(author) ?? []).map(
+                          ([_, name, email]) => ({name, email})
+                      ).value
+                    : {}
+            )
+        );
 
     const spdxLicense = packageJson
-        .then(packageJson => packageJson.license)
-        .then(mapNullableFn(parseAndCorrectSpdxExpression))
-        .catch(() => undefined)
-        .then(mapNullFn(() => undefined));
+        .then(
+            mapResultFn(packageJson =>
+                typeof packageJson?.license === "string" ? packageJson?.license : null
+            )
+        )
+        .then(mapResultFn(mapNullableFn(parseAndCorrectSpdxExpression)))
+        .then(mapResultFn(mapNullFn(() => undefined)));
 
     const today = todayUtc();
 
-    return Promise.all([npmPackage, gitHost, target, author, spdxLicense]).then(
-        ([npmPackage, gitHost, target, author, spdxLicense]) => ({
-            path,
-            npmPackage,
-            gitHost,
-            node: createNodeVersions(today),
-            target,
-            author,
-            license: {
-                spdxLicense,
-                year: today.year
-            }
-        })
+    return target.then(async target =>
+        allAsyncResults([npmPackage, gitHost, author, spdxLicense]).then(
+            mapResultFn(([npmPackage, gitHost, author, spdxLicense]) => ({
+                path,
+                npmPackage,
+                gitHost,
+                node: createNodeVersions(today),
+                target,
+                author,
+                license: {
+                    spdxLicense,
+                    year: today.year
+                }
+            }))
+        )
     );
 }
diff --git a/result/result.ts b/result/result.ts
@@ -220,6 +220,33 @@ export function chainAsyncResultsFn<TReason, TValue>(
     return async initial => chainAsyncResults(initial, actions);
 }
 
+type InferReasons<T> = T extends ReadonlyArray<Result<infer Reasons, unknown>> ? Reasons : never;
+type InferValue<T> = T extends Success<infer Value> ? Value : never;
+
+export function allResults<T extends Array<Result<unknown, unknown>>>(
+    results: readonly [...T]
+): Result<InferReasons<T>, {[K in keyof T]: InferValue<T[K]>}> {
+    return fold(
+        results,
+        (acc, result) =>
+            bindResult(acc, accValues => mapResult(result, value => [...accValues, value])),
+        success([]) as Result<any, any[]>
+    ) as any;
+}
+
+type InferAwaited<T> = T extends Promise<infer Value> ? Value : T;
+type InferAwaiteds<T extends unknown[]> = {[K in keyof T]: InferAwaited<T[K]>};
+
+export async function allAsyncResults<
+    T extends Array<Promise<Result<unknown, unknown>> | Result<unknown, unknown>>
+>(
+    results: readonly [...T]
+): Promise<
+    Result<InferReasons<InferAwaiteds<T>>, {[K in keyof T]: InferValue<InferAwaited<T[K]>>}>
+> {
+    return Promise.all(results).then(results => allResults(results) as any);
+}
+
 export function toNullable<TValue>(result: Result<unknown, TValue>): TValue | null {
     return result.type === "success" ? result.value : null;
 }
diff --git a/yarn/fix.ts b/yarn/fix.ts
@@ -1,4 +1,5 @@
-import {mapFailureFn, Result, success} from "../result/result";
+import {mapNullFn} from "@softwareventures/nullable";
+import {mapFailureFn, mapResultFn, Result, success, toNullable} from "../result/result";
 import {ProjectSource} from "../project/project";
 import {readProjectJson} from "../project/read-json";
 import {yarn} from "./yarn";
@@ -24,19 +25,14 @@ export async function yarnFixIfAvailable(project: ProjectSource): Promise<YarnFi
 
 export async function isYarnFixAvailable(project: ProjectSource): Promise<boolean> {
     return readProjectJson(project, "package.json")
-        .catch(reason => {
-            if (reason instanceof SyntaxError) {
-                return false;
-            } else if (reason.code === "ENOENT") {
-                return false;
-            } else {
-                throw reason;
-            }
-        })
         .then(
-            packageJson =>
-                typeof packageJson === "object" &&
-                typeof packageJson?.scripts === "object" &&
-                typeof packageJson?.scripts?.fix === "string"
-        );
+            mapResultFn(
+                packageJson =>
+                    typeof packageJson === "object" &&
+                    typeof packageJson?.scripts === "object" &&
+                    typeof packageJson?.scripts?.fix === "string"
+            )
+        )
+        .then(toNullable)
+        .then(mapNullFn(() => false));
 }
