fix(update): wait for each update to complete before applying the next one

Author: djcsdy

project/update.ts

@@ -1,6 +1,7 @@
 import simpleGit, {SimpleGit} from "simple-git";
 import chain from "@softwareventures/chain";
 import {concat} from "@softwareventures/array";
+import {mapFn as mapAsyncFn} from "../collections/async-iterable";
 import {FsStage, InsertResult} from "../fs-stage/fs-stage";
 import {
     bindAsyncResultFn,
@@ -15,7 +16,6 @@ import {
 import {emptyDirectory} from "../fs-stage/directory";
 import {updateCopyrightYear} from "../license/update-copyright-year";
 import {commit, CommitFailureReason} from "../fs-stage/commit";
-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";
@@ -46,14 +46,8 @@ export type UpdateStepFailureReason = YarnFixFailureReason | PrettierFixFailureR
 export async function updateProject(project: Project): Promise<UpdateResult> {
     const git = simpleGit(project.path);
 
-    return chain([
-        updateFixScript(project),
-        applyCodeStyle(project),
-        updateCopyrightYear(project),
-        addMissingLicense(project)
-    ])
-        .map(excludeNull)
-        .map(mapFn(step(project, git)))
+    return chain([updateFixScript, applyCodeStyle, updateCopyrightYear, addMissingLicense])
+        .map(mapAsyncFn(step(project, git)))
         .map(combineAsyncResults).value;
 }
 
@@ -66,40 +60,59 @@ export function gitNotClean(path: string): GitNotClean {
     return {type: "git-not-clean", path};
 }
 
-function step(project: Project, git: SimpleGit): (update: Update) => Promise<UpdateResult> {
+function step(
+    project: Project,
+    git: SimpleGit
+): (update: (project: Project) => Promise<Update | null>) => Promise<UpdateResult> {
     return async update =>
         git
             .status()
             .then(status => (status.isClean() ? success() : failure([gitNotClean(project.path)])))
-            .then(
-                bindAsyncResultFn<GitNotClean, UpdateFailureReason>(async () =>
-                    update.type === "fs-stage-update"
-                        ? update
-                              .apply({root: emptyDirectory, overwrite: true})
-                              .then(throwFailureFn("Internal error creating update file stage"))
-                              .then(async stage => commit(project.path, stage))
-                        : update.apply()
-                )
-            )
-            .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 () => update(project)))
+            .then(bindAsyncResultFn(async update => commitUpdate(project, git, update)));
+}
+
+async function commitUpdate(
+    project: Project,
+    git: SimpleGit,
+    update: Update | null
+): Promise<UpdateResult> {
+    if (update == null) {
+        return success();
+    }
+
+    return writeUpdate(project, update)
+        .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
-                        ? undefined
-                        : git.add(files).then(async () => git.commit(update.log))
-                )
+        )
+        .then(
+            mapAsyncResultFn(async files =>
+                files.length === 0
+                    ? undefined
+                    : git.add(files).then(async () => git.commit(update.log))
             )
-            .then(
-                mapResultFn(commitResult => {
-                    if (commitResult != null) {
-                        console.log(`Applied update: ${update.log}`);
-                    }
-                })
-            );
+        )
+        .then(
+            mapResultFn(commitResult => {
+                if (commitResult != null) {
+                    console.log(`Applied update: ${update.log}`);
+                }
+            })
+        );
+}
+
+async function writeUpdate(project: Project, update: Update): Promise<UpdateResult> {
+    switch (update.type) {
+        case "fs-stage-update":
+            return update
+                .apply({root: emptyDirectory, overwrite: true})
+                .then(throwFailureFn("Internal error creating update file stage"))
+                .then(async stage => commit(project.path, stage));
+        case "direct-update":
+            return update.apply();
+    }
 }

result/result.ts

@@ -57,7 +57,7 @@ export function mapResultFn<TReason, TValue, TNewValue>(
 
 export async function mapAsyncResult<TReason, TValue, TNewValue>(
     result: Result<TReason, TValue>,
-    f: (value: TValue) => PromiseLike<TNewValue>
+    f: (value: TValue) => PromiseLike<TNewValue> | TNewValue
 ): Promise<Result<TReason, TNewValue>> {
     if (result.type === "success") {
         return Promise.resolve(f(result.value)).then(value => ({type: "success", value}));
@@ -67,7 +67,7 @@ export async function mapAsyncResult<TReason, TValue, TNewValue>(
 }
 
 export function mapAsyncResultFn<TReason, TValue, TNewValue>(
-    f: (value: TValue) => PromiseLike<TNewValue>
+    f: (value: TValue) => PromiseLike<TNewValue> | TNewValue
 ): (result: Result<TReason, TValue>) => Promise<Result<TReason, TNewValue>> {
     return async result => mapAsyncResult(result, f);
 }