fix(execa): use await execa instead of execaSync since it produce…

…s unexpected errors when spawning git commands - fixes #17

Co-authored-by: syphernl <syphernl@users.noreply.github.com>

Signed-off-by: kilianpaquier <kilian@kilianpaquier.com>

index.ts

@@ -31,7 +31,7 @@ export const verifyConditions = (globalConfig: BackmergeConfig, context: VerifyC
 /**
  * success is the function for semantic-release success lifecycle.
  * 
- * It executes the backmerge to all appropriate branches as the release was successfull.
+ * It executes the backmerge to all appropriate branches as the release was successful.
  * 
  * @param globalConfig the semantic-release-backmerge plugin configuration.
  * @param context the semantic-release context.
@@ -40,7 +40,7 @@ export const success = async (globalConfig: BackmergeConfig, context: SuccessCon
     const config = verifyConditions(globalConfig, context)
 
     try {
-        const branches = getBranches(context, config)
+        const branches = await getBranches(context, config)
         await executeBackmerge(context, config, branches)
     } catch (error) {
         if (error instanceof AggregateError || error instanceof SemanticReleaseError) {

lib/auth-modificator.ts

@@ -3,7 +3,7 @@ import { Platform } from "./models/config"
 import { getConfigError } from "./error"
 
 /**
- * getUser returns the appropriate string user for the given input platform. 
+ * getUser returns the appropriate string user for the given input platform.
  * It's specifically used in AuthModificator function for the auth user token.
  * 
  * @see https://github.com/semantic-release/semantic-release/blob/master/lib/get-git-auth-url.js#L64

lib/backmerge.ts

@@ -12,7 +12,7 @@ import { authModificator } from "./auth-modificator"
 import { template } from "lodash"
 
 /**
- * Context is a subinterface of semantic-release Context (specifically VerifyConditionContext)
+ * Context is a subinterface of semantic-release Context (specifically VerifyConditionContext).
  */
 export interface Context {
     branch: { name: string }
@@ -27,7 +27,8 @@ export interface Context {
 }
 
 /**
- * getBranches returns the slice of branches that can be backmerged. 
+ * getBranches returns the slice of branches that can be backmerged.
+ * 
  * To retrieve them, it takes into account their existence in remote repository, their presence in input targets, 
  * and their semver version value related to the appropriate target (for instance, a branch v1.0 won't be returned if target.from is v1.1).
  * 
@@ -38,7 +39,7 @@ export interface Context {
  * 
  * @returns the slice of branches where the context.branch.name must be backmerged into.
  */
-export const getBranches = (context: Context, config: BackmergeConfig) => {
+export const getBranches = async (context: Context, config: BackmergeConfig) => {
     const releaseBranch = context.branch.name
 
     const appropriates = config.targets.filter(branch => releaseBranch.match(branch.from))
@@ -51,12 +52,19 @@ export const getBranches = (context: Context, config: BackmergeConfig) => {
     const url = parse(config.repositoryUrl)
     const authRemote = authModificator(url, config.platform, config.token)
 
-    // ensure at any time and any moment that the fetch'ed remote url is the same as there
-    // https://github.com/semantic-release/git/blob/master/lib/prepare.js#L69
-    // it's to ensure that the commit done during @semantic-release/git is backmerged alongside the other commits
-    fetch(authRemote, context.cwd, context.env)
+    let branches: string[] = [] // eslint-disable-line no-useless-assignment
+    try {
+        // ensure at any time and any moment that the fetch'ed remote url is the same as there
+        // https://github.com/semantic-release/git/blob/master/lib/prepare.js#L69
+        // it's to ensure that the commit done during @semantic-release/git is backmerged alongside the other commits
+        await fetch(authRemote, context.cwd, context.env)
+
+        branches = await ls(config.repositoryUrl, context.cwd, context.env)
+    } catch (error) {
+        throw new SemanticReleaseError("Failed to fetch git remote or list all branches.", "ELSREMOTE", String(error))
+    }
 
-    const branches = ls(config.repositoryUrl, context.cwd, context.env).
+    const filteredBranches = branches.
         // don't keep the released branch
         filter(branch => releaseBranch !== branch).
 
@@ -82,24 +90,24 @@ export const getBranches = (context: Context, config: BackmergeConfig) => {
 
                 // don't merge into older versions
                 if (semver.lt(branchMaintenance, releaseMaintenance)) {
-                    context.logger.log(`Not backmerging into '${branch}' since the semver version is before '${releaseBranch}'.`)
+                    context.logger.log(`Not backmerging into '${branch}' since semver version is before '${releaseBranch}'.`)
                     return false
                 }
 
                 // don't merge minor versions into next majors versions
                 if (semver.gte(branchMaintenance, nextMajor!)) {
-                    context.logger.log(`Not backmerging into '${branch}' since the semver major version is after '${releaseBranch}'.`)
+                    context.logger.log(`Not backmerging into '${branch}' since semver major version is after '${releaseBranch}'.`)
                     return false
                 }
             }
             return true
         })
-    if (branches.length === 0) {
+    if (filteredBranches.length === 0) {
         context.logger.log("No configured target is present in remote origin, no backmerge to be done.")
         return []
     }
-    context.logger.log(`Retrieved following branches present in remote origin: '${JSON.stringify(branches)}'`)
-    return branches
+    context.logger.log(`Retrieved branches present in remote origin: '${JSON.stringify(filteredBranches)}'`)
+    return filteredBranches
 }
 
 /**
@@ -120,13 +128,17 @@ export const executeBackmerge = async (context: Context, config: BackmergeConfig
     const url = parse(config.repositoryUrl)
     const authRemote = authModificator(url, config.platform, config.token)
 
-    // ensure at any time and any moment that the fetch'ed remote url is the same as there
-    // https://github.com/semantic-release/git/blob/master/lib/prepare.js#L69
-    // it's to ensure that the commit done during @semantic-release/git is backmerged alongside the other commits
-    fetch(authRemote, context.cwd, context.env)
+    try {
+        // ensure at any time and any moment that the fetch'ed remote url is the same as there
+        // https://github.com/semantic-release/git/blob/master/lib/prepare.js#L69
+        // it's to ensure that the commit done during @semantic-release/git is backmerged alongside the other commits
+        await fetch(authRemote, context.cwd, context.env)
 
-    // checkout to ensure released branch is up to date with last fetch'ed remote url
-    checkout(releaseBranch, context.cwd, context.env)
+        // checkout to ensure released branch is up to date with last fetch'ed remote url
+        await checkout(releaseBranch, context.cwd, context.env)
+    } catch (error) {
+        throw new SemanticReleaseError(`Failed to fetch or checkout released branch '${releaseBranch}'.`, "ECHECKOUT", String(error))
+    }
 
     const errors: SemanticReleaseError[] = []
     for (const branch of branches) { // keep await in loop since git actions aren't thread safe
@@ -138,12 +150,11 @@ export const executeBackmerge = async (context: Context, config: BackmergeConfig
         }
 
         try {
-            merge(releaseBranch, branch, template(config.commit)(templateData), context.cwd, context.env)
-
+            await merge(releaseBranch, branch, template(config.commit)(templateData), context.cwd, context.env)
             if (config.dryRun) {
                 context.logger.log(`Running with --dry-run, push to '${branch}' will not update remote state.`)
             }
-            push(authRemote, branch, config.dryRun, context.cwd, context.env)
+            await push(authRemote, branch, config.dryRun, context.cwd, context.env)
         } catch (error) {
             context.logger.error(`Failed to backmerge '${releaseBranch}' into '${branch}', opening pull request.`, error)
 

lib/git.ts

@@ -1,15 +1,15 @@
-import { execaSync } from "execa"
+import { execa } from "execa"
 
 /**
- * ls returns the slice of all branches present in remote origin. 
+ * ls returns the slice of all branches present in remote origin.
  * It removes 'refs/heads/' from the branches name.
  * 
  * @returns the slice of branches.
  * 
- * @throws an error is the git ls-remote cannot be done.
+ * @throws an error if the git ls-remote cannot be done.
  */
-export const ls = (remote: string, cwd?: string, env?: Record<string, string>) => {
-    const { stdout } = execaSync("git", ["ls-remote", "--heads", remote], { cwd, env })
+export const ls = async (remote: string, cwd?: string, env?: Record<string, string>) => {
+    const { stdout } = await execa("git", ["ls-remote", "--heads", remote], { cwd, env })
     const branches = stdout.
         split("\n").
         map(branch => branch.split("\t")).
@@ -20,15 +20,16 @@ export const ls = (remote: string, cwd?: string, env?: Record<string, string>) =
 }
 
 /**
- * checkout executes a simple checkout of input branch. 
+ * checkout executes a simple checkout of input branch.
+ * 
  * The checkout is strict with remote state, meaning all local changes are removed.
  * 
  * @param branch the input branch to checkout.
  * 
  * @throws an error if the checkout cannot be done.
  */
-export const checkout = (branch: string, cwd?: string, env?: Record<string, string>) => {
-    execaSync("git", ["checkout", "-B", branch], { cwd, env })
+export const checkout = async (branch: string, cwd?: string, env?: Record<string, string>) => {
+    await execa("git", ["checkout", "-B", branch], { cwd, env })
 }
 
 /**
@@ -38,12 +39,13 @@ export const checkout = (branch: string, cwd?: string, env?: Record<string, stri
  * 
  * @throws an error if the fetch cannot be done.
  */
-export const fetch = (remote: string, cwd?: string, env?: Record<string, string>) => {
-    execaSync("git", ["fetch", remote], { cwd, env })
+export const fetch = async (remote: string, cwd?: string, env?: Record<string, string>) => {
+    await execa("git", ["fetch", remote], { cwd, env })
 }
 
 /**
  * merge executes a checkout of input 'to' branch, and merges input 'from' branch into 'to'.
+ * 
  * If a merge commit must be done (by default --ff is used), then the merge commit is the input commit.
  * 
  * @param from the branch to merge into 'to'.
@@ -52,13 +54,13 @@ export const fetch = (remote: string, cwd?: string, env?: Record<string, string>
  * 
  * @throws an error if the merge fails (in case of conflicts, etc.).
  */
-export const merge = (from: string, to: string, commit: string, cwd?: string, env?: Record<string, string>) => {
-    checkout(to)
+export const merge = async (from: string, to: string, commit: string, cwd?: string, env?: Record<string, string>) => {
+    await checkout(to)
 
     try {
-        execaSync("git", ["merge", `${from}`, "--ff", "-m", commit], { cwd, env })
+        await execa("git", ["merge", `${from}`, "--ff", "-m", commit], { cwd, env })
     } catch (error) {
-        execaSync("git", ["merge", "--abort"], { cwd, env })
+        await execa("git", ["merge", "--abort"], { cwd, env })
         throw error
     }
 }
@@ -71,10 +73,10 @@ export const merge = (from: string, to: string, commit: string, cwd?: string, en
  * 
  * @throws an error if the push cannot be executed.
  */
-export const push = (remote: string, branch: string, dryRun?: boolean, cwd?: string, env?: Record<string, string>) => {
+export const push = async (remote: string, branch: string, dryRun?: boolean, cwd?: string, env?: Record<string, string>) => {
     const args = ["push", remote, `HEAD:${branch}`]
     if (dryRun) {
         args.push("--dry-run")
     }
-    execaSync("git", args, { cwd, env })
+    await execa("git", args, { cwd, env })
 }