@cmflow/cli 1.0.16 → 1.1.1-alpha.1

package/src/commands/rebase.js

@@ -1,13 +1,14 @@
-import chalk from 'chalk'
-import figures from 'figures'
-import { Fetch } from './fetch.js'
-import { git } from '../common/cli/git.js'
-import { updateBranch } from './tasks/update-branch.js'
-import { updateDependencies } from './tasks/update-dependencies.js'
-import { runTest } from './tasks/run-test.js'
+import chalk from "chalk";
+import figures from "figures";
+
+import { git } from "../common/cli/git.js";
+import { Fetch } from "./fetch.js";
+import { runTest } from "./tasks/run-test.js";
+import { updateBranch } from "./tasks/update-branch.js";
+import { updateDependencies } from "./tasks/update-dependencies.js";
 
 export class Rebase extends Fetch {
-  mapContext (commander, context) {
+  mapContext(commander, context) {
     return {
       ...context,
       useYarn: context.HAS_YARN,
@@ -19,20 +20,17 @@ export class Rebase extends Fetch {
       skipTest: !commander.cucumber && !commander.unitTest,
       skipUnit: !commander.unitTest,
       skipE2E: context.HAS_E2E ? !commander.cucumber : true
-    }
+    };
   }
 
-  getTasks (context) {
-    return [
-      ...super.getTasks(context),
-      updateBranch(context),
-      updateDependencies(context),
-      ...runTest(context)
-    ]
+  getTasks(context) {
+    return [...super.getTasks(context), updateBranch(context), updateDependencies(context), ...runTest(context)];
   }
 
-  success (context) {
-    // eslint-disable-next-line no-console
-    console.log(chalk.green(figures.tick), `Branch ${chalk.green(context.featureBranch)} rebased from ${chalk.green(context.fromBranch)} HEAD`)
+  success(context) {
+    console.log(
+      chalk.green(figures.tick),
+      `Branch ${chalk.green(context.featureBranch)} rebased from ${chalk.green(context.fromBranch)} HEAD`
+    );
   }
 }

package/src/commands/release.js

@@ -1,22 +1,21 @@
-import semantic_release from 'semantic-release'
+import semantic_release from "semantic-release";
 
-delete process.env.CIRCLE_PR_NUMBER
-delete process.env.CIRCLE_PULL_REQUEST
-delete process.env.CI_PULL_REQUEST
+delete process.env.CIRCLE_PR_NUMBER;
+delete process.env.CIRCLE_PULL_REQUEST;
+delete process.env.CI_PULL_REQUEST;
 
-export function release (options = {}) {
+export function release(options = {}) {
   semantic_release({
-    dryRun: process.argv.includes('--dry-run'),
+    dryRun: process.argv.includes("--dry-run"),
     ci: false,
     noCi: true,
     ...options
   })
     .then(() => {
-      process.exitCode = 0
+      process.exitCode = 0;
     })
     .catch((err) => {
-      // eslint-disable-next-line no-console
-      console.log('Error while releasing', err)
-      process.exitCode = 1
-    })
+      console.log("Error while releasing", err);
+      process.exitCode = 1;
+    });
 }

package/src/commands/republish.js

@@ -1,24 +1,21 @@
-import chalk from 'chalk'
-import figures from 'figures'
-import { Fetch } from './fetch.js'
-import { rebaseAllBranches } from './tasks/rebase-all-branches.js'
+import chalk from "chalk";
+import figures from "figures";
+
+import { Fetch } from "./fetch.js";
+import { rebaseAllBranches } from "./tasks/rebase-all-branches.js";
 
 export class Republish extends Fetch {
-  mapContext (commander, context) {
+  mapContext(commander, context) {
     return {
       ...super.mapContext(commander, context)
-    }
+    };
   }
 
-  getTasks (context) {
-    return [
-      ...super.getTasks(context),
-      rebaseAllBranches(context)
-    ]
+  getTasks(context) {
+    return [...super.getTasks(context), rebaseAllBranches(context)];
   }
 
-  success (context) {
-    // eslint-disable-next-line no-console
-    console.log(chalk.green(figures.tick), 'All branches rebased and pushed.')
+  success() {
+    console.log(chalk.green(figures.tick), "All branches rebased and pushed.");
   }
 }

package/src/commands/start.js

@@ -1,82 +1,110 @@
-import chalk from 'chalk'
-import figures from 'figures'
-import { git } from '../common/cli/git.js'
-import { branches } from './prompts/branches.js'
-import { Fetch } from './fetch.js'
+import chalk from "chalk";
+import figures from "figures";
 
-import { updateDependencies } from './tasks/update-dependencies.js'
-import { WORKFLOW_CONFIGURATION } from '../workflow/index.js'
+import { git } from "../common/cli/git.js";
+import { WORKFLOW_CONFIGURATION } from "../workflow/index.js";
+import { Fetch } from "./fetch.js";
+import { branches } from "./prompts/branches.js";
+import { updateDependencies } from "./tasks/update-dependencies.js";
 
-function sanitize (name) {
-  return name.replace(/[/\\_|. ]/gi, '-').split('-').filter(Boolean).join('-')
+function sanitize(name) {
+  return name
+    .replace(/[/\\_|. ]/gi, "-")
+    .split("-")
+    .filter(Boolean)
+    .join("-");
 }
 
 export class Start extends Fetch {
-  mapContext (options, context) {
-    options.branchName = options.branchName || ''
-    const type = WORKFLOW_CONFIGURATION
-      .map(({ type }) => type)
-      .find((t) => options.branchName.startsWith(`${t}-`))
+  mapContext(options, context) {
+    options.branchName = options.branchName || "";
+    const type = WORKFLOW_CONFIGURATION.map(({ type }) => type).find((t) => options.branchName.startsWith(`${t}-`));
+
+    if (!options.branchName && options.jiraId) {
+      options.branchName = options.jiraId;
+    }
+
+    if (options.branchName.startsWith("CMAB-")) {
+      const [, key, ...rest] = options.branchName.split("-");
+      options.jiraId = `CMAB-${key}`;
+      options.branchName = rest.join("-");
+    }
 
     return {
       ...context,
       useYarn: context.HAS_YARN,
       origin: context.ORIGIN,
+      jiraId: options.jiraId,
       branchName: options.branchName,
       type
-    }
+    };
   }
 
-  prompt (context) {
+  prompt(context) {
     return [
       {
-        type: 'list',
-        name: 'type',
-        message: 'Choose the type of your branch:',
-        choices: ['fix', 'feat', 'chore', 'docs', 'tech'],
+        type: "input",
+        name: "jiraId",
+        message: "What is the Jira ID ? (leave blank to skip)",
+        default: context.jiraId,
+        when: !context.jiraId
+      },
+      {
+        type: "list",
+        name: "type",
+        message: "Choose the type of your branch:",
+        choices: ["fix", "feat", "chore", "docs", "tech"],
         default: context.type,
-        when: !context.type
+        when: !context.type && !context.jiraId
       },
       {
-        type: 'input',
-        name: 'branchName',
-        message: 'What is the branch name ?',
-        validate (branch) {
+        type: "input",
+        name: "branchName",
+        message: "What is the branch name ?",
+        validate(branch) {
           if (!branch.length) {
-            return 'Branch name is required'
+            return "Branch name is required";
           }
 
           if (git.branchExists(branch, context.origin)) {
-            return `${branch} already exists`
+            return `${branch} already exists`;
           }
 
-          return true
+          return true;
         },
 
         when: !context.branchName
       },
 
       branches(context)
-    ]
+    ];
   }
 
-  getTasks (context) {
-    context.branchName = sanitize(context.branchName)
-    context.featureBranch = context.branchName.includes(context.type + '-') ? context.branchName : `${context.type}-${context.branchName}`
-    context.fromBranch = context.fromBranch || context.PRODUCTION_BRANCH
+  getTasks(context) {
+    context.branchName = sanitize(context.branchName);
+
+    context.featureBranch = context.jiraId
+      ? `${context.jiraId}-${context.branchName}`
+      : context.branchName.includes(context.type + "-")
+        ? context.branchName
+        : `${context.type}-${context.branchName}`;
+
+    context.fromBranch = context.fromBranch || context.PRODUCTION_BRANCH;
 
     return [
       ...super.getTasks(context),
       {
         title: `Create branch from ${chalk.green(context.fromBranch)}`,
-        task: () => git.checkout('--no-track', '-b', context.featureBranch, context.fromBranch).toObservable()
+        task: () => git.checkout("--no-track", "-b", context.featureBranch, context.fromBranch).toObservable()
       },
       updateDependencies(context)
-    ]
+    ];
   }
 
-  success (context) {
-    // eslint-disable-next-line no-console
-    console.log(chalk.green(figures.tick), `New branch ${chalk.green(context.featureBranch)} created from ${chalk.green(context.fromBranch)} HEAD`)
+  success(context) {
+    console.log(
+      chalk.green(figures.tick),
+      `New branch ${chalk.green(context.featureBranch)} created from ${chalk.green(context.fromBranch)} HEAD`
+    );
   }
 }

package/src/commands/tasks/merge-branch.js

@@ -1,61 +1,65 @@
-import { git } from '../../common/index.js'
+import { git } from "../../common/index.js";
 
-function setGHToken (context) {
+function setGHToken(context) {
   const {
     logger,
-    config: { GH_TOKEN, REPOSITORY_URL, ORIGIN }
-  } = context
+    config: { SCM_TOKEN, REPOSITORY_URL, ORIGIN }
+  } = context;
 
-  if (GH_TOKEN) {
-    const repository = REPOSITORY_URL.replace('https://', '')
+  if (SCM_TOKEN) {
+    const repository = REPOSITORY_URL.replace("https://", "");
 
-    logger.info(`Configure remote repository ${repository}`)
-    git.remote('remove', ORIGIN).sync()
-    git.remote('add', ORIGIN, `https://${GH_TOKEN}@${repository}`).sync()
+    logger.info(`Configure remote repository ${repository}`);
+    git.remote("remove", ORIGIN).sync();
+    git.remote("add", ORIGIN, `https://${SCM_TOKEN}@${repository}`).sync();
   }
 }
 
-async function gitMep (context) {
-  const { logger, branch, config: { PRODUCTION_BRANCH, ORIGIN } } = context
+async function gitMep(context) {
+  const {
+    logger,
+    branch,
+    config: { PRODUCTION_BRANCH, ORIGIN }
+  } = context;
 
-  logger.info(`Branch ${branch.name} is candidate to MEP`)
+  logger.info(`Branch ${branch.name} is candidate to MEP`);
 
-  git.reset('--hard')
-  git.clean('-f', '-d').sync()
+  git.reset("--hard");
+  git.clean("-f", "-d").sync();
 
-  logger.info('Checkout production branch')
+  logger.info("Checkout production branch");
 
-  git.config('--replace-all', 'remote.origin.fetch', '+refs/heads/*:refs/remotes/origin/*')
-  git.fetch().sync()
-  git.fetch('--tags').sync()
-  git.checkout('-qf', PRODUCTION_BRANCH).sync()
+  git.config("--replace-all", "remote.origin.fetch", "+refs/heads/*:refs/remotes/origin/*");
+  git.fetch().sync();
+  git.fetch("--tags").sync();
+  git.checkout("-qf", PRODUCTION_BRANCH).sync();
 
-  logger.info(`Current branch: ${PRODUCTION_BRANCH}`)
+  logger.info(`Current branch: ${PRODUCTION_BRANCH}`);
 
-  const building = git.getLastCommitMsg()
-  logger.info('Last commit message on production', building)
+  const building = git.getLastCommitMsg();
+  logger.info("Last commit message on production", building);
 
-  logger.info(`Merge ${branch.name} into ${PRODUCTION_BRANCH} branch`)
-  git.merge('--no-ff', '-m', `${branch.name}`, branch.name)
-  logger.info(`${branch.name} merged into ${PRODUCTION_BRANCH} branch`)
+  logger.info(`Merge ${branch.name} into ${PRODUCTION_BRANCH} branch`);
+  git.merge("--no-ff", "-m", `${branch.name}`, branch.name);
+  logger.info(`${branch.name} merged into ${PRODUCTION_BRANCH} branch`);
 
-  setGHToken(context)
+  setGHToken(context);
 
-  logger.info(`Push ${PRODUCTION_BRANCH} branch`)
-  await git.push(ORIGIN, PRODUCTION_BRANCH)
-  logger.info(`${PRODUCTION_BRANCH} branch pushed`)
+  logger.info(`Push ${PRODUCTION_BRANCH} branch`);
+  await git.push(ORIGIN, PRODUCTION_BRANCH);
+  logger.info(`${PRODUCTION_BRANCH} branch pushed`);
 
-  logger.info(`Remove ${ORIGIN}/${branch.name} branch`)
-  await git.push(ORIGIN, ':' + branch.name)
-  logger.info(`${ORIGIN}/${branch.name} branch correctly removed`)
+  logger.info(`Remove ${ORIGIN}/${branch.name} branch`);
+  await git.push(ORIGIN, ":" + branch.name);
+  logger.info(`${ORIGIN}/${branch.name} branch correctly removed`);
 }
 
-export function mergeBranch (context) {
-  const { BRANCH_NAME, PRODUCTION_BRANCH } = context
-  return ({
+export function mergeBranch(context) {
+  const { BRANCH_NAME, PRODUCTION_BRANCH } = context;
+  return {
     title: `Merge ${BRANCH_NAME} into ${PRODUCTION_BRANCH}`,
     task: async () => {
-      await gitMep(context)
+      await gitMep(context);
     }
-  })
+  };
 }

package/src/commands/tasks/push-branch.js

@@ -1,16 +1,10 @@
-import { git } from '../../common/cli/git.js'
+import { git } from "../../common/cli/git.js";
 
-export function pushBranch ({ origin = 'origin', featureBranch, upstream = true, noVerify = true }) {
-  return ({
+export function pushBranch({ origin = "origin", featureBranch, upstream = true, noVerify = true }) {
+  return {
     title: `Push ${featureBranch}`,
     task: () => {
-      return git.push(...[
-        upstream ? '-u' : '',
-        '-f',
-        origin,
-        featureBranch,
-        noVerify ? '--no-verify' : ''
-      ].filter(Boolean)).toObservable()
+      return git.push(...[upstream ? "-u" : "", "-f", origin, featureBranch, noVerify ? "--no-verify" : ""].filter(Boolean)).toObservable();
     }
-  })
+  };
 }

package/src/commands/tasks/rebase-all-branches.js

@@ -1,34 +1,29 @@
-import { git } from '../../common/cli/git.js'
+import { git } from "../../common/cli/git.js";
 
-export function rebaseAllBranches (context) {
-  const { origin = 'origin', upstream = true, noVerify = true } = context
-  return ({
-    title: 'Rebase all branches',
+export function rebaseAllBranches(context) {
+  const { origin = "origin", upstream = true, noVerify = true } = context;
+  return {
+    title: "Rebase all branches",
     task: async () => {
-      const remoteBranches = git.branches('-r')
-        .filter(b => !new RegExp(`${context.PRODUCTION_BRANCH}|${context.DEVELOP_BRANCH}`).test(b))
+      const remoteBranches = git
+        .branches("-r")
+        .filter((b) => !new RegExp(`${context.PRODUCTION_BRANCH}|${context.DEVELOP_BRANCH}`).test(b));
       for (const remoteBranch of remoteBranches) {
-        const branch = remoteBranch.split('/')[1]
+        const branch = remoteBranch.split("/")[1];
         try {
-          await git.branch('-D', branch)
-        } catch (e) {}
+          await git.branch("-D", branch);
+        } catch {}
         try {
-          await git.checkout('--track', remoteBranch)
-          await git.rebase(`${origin}/${context.PRODUCTION_BRANCH}`)
-          await git.push(...[
-            upstream ? '-u' : '',
-            '-f',
-            origin,
-            branch,
-            noVerify ? '--no-verify' : ''
-          ].filter(Boolean))
-        } catch (e) {
+          await git.checkout("--track", remoteBranch);
+          await git.rebase(`${origin}/${context.PRODUCTION_BRANCH}`);
+          await git.push(...[upstream ? "-u" : "", "-f", origin, branch, noVerify ? "--no-verify" : ""].filter(Boolean));
+        } catch {
           try {
-            await git.rebase('--abort')
-            await git.reset('--hard')
-          } catch (e) {}
+            await git.rebase("--abort");
+            await git.reset("--hard");
+          } catch {}
         }
       }
     }
-  })
+  };
 }

package/src/commands/tasks/refresh-repository.js

@@ -1,32 +1,34 @@
-import { catchError, EMPTY } from 'rxjs'
-import Listr from 'listr'
-import { git } from '../../common/index.js'
+import Listr from "listr";
+import { catchError, EMPTY } from "rxjs";
 
-function pipe (observable, output) {
-  observable.pipe(catchError((err) => {
-    output.push(err)
-    return EMPTY
-  }))
+import { git } from "../../common/index.js";
 
-  observable.subscribe(result => {
-    output.push(result)
-  })
+function pipe(observable, output) {
+  observable.pipe(
+    catchError((err) => {
+      output.push(err);
+      return EMPTY;
+    })
+  );
 
-  return observable
+  observable.subscribe((result) => {
+    output.push(result);
+  });
+
+  return observable;
 }
 
-export function refreshRepository (context) {
-  const {
-    output = []
-  } = context
+export function refreshRepository(context) {
+  const { output = [] } = context;
 
   return {
-    title: 'Refresh local repository',
-    task: () => new Listr([
-      {
-        title: 'Git fetch',
-        task: () => pipe(git.fetch('--prune').toObservable(), output)
-      }
-    ])
-  }
+    title: "Refresh local repository",
+    task: () =>
+      new Listr([
+        {
+          title: "Git fetch",
+          task: () => pipe(git.fetch("--prune").toObservable(), output)
+        }
+      ])
+  };
 }

package/src/commands/tasks/run-test.js

@@ -1,29 +1,23 @@
-import { git, npm, yarn } from '../../common/index.js'
+import { git, npm, yarn } from "../../common/index.js";
 
-export const runTest = ({
-  E2E_CMD,
-  useYarn,
-  skipTest,
-  skipUnit,
-  skipE2E
-}) => {
-  const manager = useYarn ? yarn : npm
+export const runTest = ({ E2E_CMD, useYarn, skipTest, skipUnit, skipE2E }) => {
+  const manager = useYarn ? yarn : npm;
 
   return [
     {
-      title: 'Unit test',
+      title: "Unit test",
       skip: () => skipTest || skipUnit,
-      task: () => manager.run('test')
+      task: () => manager.run("test")
     },
     {
-      title: 'E2E test',
+      title: "E2E test",
       skip: () => skipTest || skipE2E,
-      task: () => manager.run(E2E_CMD || 'test_e2e')
+      task: () => manager.run(E2E_CMD || "test_e2e")
     },
     {
-      title: 'Reset changes',
+      title: "Reset changes",
       skip: () => skipTest,
-      task: () => git.reset('--hard') // reset files updated unit test
+      task: () => git.reset("--hard") // reset files updated unit test
     }
-  ]
-}
+  ];
+};

package/src/commands/tasks/update-branch.js

@@ -1,40 +1,43 @@
-import chalk from 'chalk'
-import Listr from 'listr'
-import { git } from '../../common/cli/git.js'
+import chalk from "chalk";
+import Listr from "listr";
 
-async function checkBranchRemoteStatus ({ featureBranch, origin, force }) {
-  const isBranchExists = git.branchExists(featureBranch, origin)
+import { git } from "../../common/cli/git.js";
+
+async function checkBranchRemoteStatus({ featureBranch, origin, force }) {
+  const isBranchExists = git.branchExists(featureBranch, origin);
 
   if (isBranchExists && !force) {
-    const result = git.checkBranchRemoteStatus(featureBranch)
+    const result = git.checkBranchRemoteStatus(featureBranch);
 
     if (result) {
-      throw new Error('Remote branch changed, check diff before continue')
+      throw new Error("Remote branch changed, check diff before continue");
     }
   }
 }
 
 export const updateBranch = ({ origin, featureBranch, fromBranch, force, checkStatus = true, rebase = true }) => {
-  return ({
-    title: 'Rebase branch',
-    task: () => new Listr(
-      [
-        {
-          title: 'Check status',
-          enabled: () => checkStatus,
-          task: () => checkBranchRemoteStatus({
-            force,
-            featureBranch,
-            origin
-          })
-        },
-        {
-          title: `Rebase from ${origin}/${chalk.green(fromBranch)}`,
-          enabled: () => rebase,
-          task: () => git.rebase(`${origin}/${fromBranch}`).toObservable()
-        }
-      ],
-      { concurrent: false }
-    )
-  })
-}
+  return {
+    title: "Rebase branch",
+    task: () =>
+      new Listr(
+        [
+          {
+            title: "Check status",
+            enabled: () => checkStatus,
+            task: () =>
+              checkBranchRemoteStatus({
+                force,
+                featureBranch,
+                origin
+              })
+          },
+          {
+            title: `Rebase from ${origin}/${chalk.green(fromBranch)}`,
+            enabled: () => rebase,
+            task: () => git.rebase(`${origin}/${fromBranch}`).toObservable()
+          }
+        ],
+        { concurrent: false }
+      )
+  };
+};