feat(prettier): apply prettier code style to modified files after each update

Author: djcsdy

cli/update.ts

@@ -21,6 +21,7 @@ export function cliUpdate(path: string, options: object): void {
                                 case "git-not-clean":
                                     return `Git working copy not clean: ${reason.path}`;
                                 case "yarn-fix-failed":
+                                case "prettier-fix-failed":
                                     return `Failed to apply code style rules: ${reason.path}`;
                             }
                         })

prettier/fix.ts

@@ -0,0 +1,76 @@
+import {resolve} from "path";
+import {mapFn} from "@softwareventures/array";
+import {ProjectSource} from "../project/project";
+import {readProjectJson} from "../project/read-json";
+import {combineAsyncResults, mapFailureFn, Result, success} from "../result/result";
+import {yarn} from "../yarn/yarn";
+
+export type PrettierFixResult = Result<PrettierFixFailureReason>;
+
+export interface PrettierFixFailureReason {
+    readonly type: "prettier-fix-failed";
+    readonly path: string;
+}
+
+export async function prettierFixFiles(
+    project: ProjectSource,
+    relativePaths: readonly string[]
+): Promise<PrettierFixResult> {
+    return Promise.resolve(relativePaths)
+        .then(
+            mapFn(async path =>
+                yarn(project.path, "prettier", "--write", path).then(
+                    mapFailureFn(
+                        (): PrettierFixFailureReason => ({
+                            type: "prettier-fix-failed",
+                            path: resolve(project.path, path)
+                        })
+                    )
+                )
+            )
+        )
+        .then(combineAsyncResults);
+}
+
+export async function prettierFixFilesIfAvailable(
+    project: ProjectSource,
+    relativePaths: readonly string[]
+): Promise<PrettierFixResult> {
+    return isPrettierAvailable(project).then(async available =>
+        available ? prettierFixFiles(project, relativePaths) : success()
+    );
+}
+
+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)
+        );
+}
+
+function packageJsonDependsOnPrettier(packageJson: any): boolean {
+    return (
+        typeof packageJson === "object" &&
+        ((typeof packageJson?.dependencies === "object" &&
+            typeof packageJson?.dependencies?.prettier === "string") ||
+            (typeof packageJson?.devDependencies === "object" &&
+                typeof packageJson?.devDependencies?.prettier === "string"))
+    );
+}
+
+function yarnPrettierCanRun(packageJson: any): boolean {
+    return (
+        typeof packageJson === "object" &&
+        (typeof packageJson?.scripts !== "object" ||
+            packageJson?.scripts?.prettier == null ||
+            String(packageJson?.scripts?.prettier).trim() === "prettier")
+    );
+}

project/update.ts

@@ -19,6 +19,7 @@ import {excludeNull, mapFn} from "../collections/async-iterable";
 import {addMissingLicense} from "../license/add-missing-license";
 import {YarnFixFailureReason} from "../yarn/fix";
 import {applyCodeStyle} from "../yarn/apply-code-style";
+import {PrettierFixFailureReason, prettierFixFilesIfAvailable} from "../prettier/fix";
 import {Project} from "./project";
 
 export type Update = FsStageUpdate | DirectUpdate;
@@ -39,7 +40,7 @@ export type UpdateResult = Result<UpdateFailureReason>;
 
 export type UpdateFailureReason = GitNotClean | CommitFailureReason | UpdateStepFailureReason;
 
-export type UpdateStepFailureReason = YarnFixFailureReason;
+export type UpdateStepFailureReason = YarnFixFailureReason | PrettierFixFailureReason;
 
 export async function updateProject(project: Project): Promise<UpdateResult> {
     const git = simpleGit(project.path);
@@ -80,6 +81,11 @@ function step(project: Project, git: SimpleGit): (update: Update) => Promise<Upd
             )
             .then(mapAsyncResultFn(async () => git.status()))
             .then(mapResultFn(status => concat([status.modified, status.not_added])))
+            .then(
+                bindAsyncResultFn(async files =>
+                    prettierFixFilesIfAvailable(project, files).then(mapResultFn(() => files))
+                )
+            )
             .then(
                 mapAsyncResultFn(async files =>
                     files.length === 0