@cmflow/cli 1.1.0 → 1.1.1-alpha.1

package/src/common/get-config.js

@@ -1,178 +1,122 @@
-import hasYarn from 'has-yarn'
-import get from 'lodash/get.js'
-import { git } from './cli/git.js'
-import { getPackageJson } from './get-package-json.js'
-import fs from 'fs'
-import { join } from 'path'
+import fs from "node:fs";
+import { join } from "node:path";
 
-const toBool = (value) => {
-  if (value === 'false') return false
-  if (value === '0') return false
+import hasYarn from "has-yarn";
+import get from "lodash/get.js";
 
-  return !!value
-}
+import { git } from "./cli/git.js";
+import { getPackageJson } from "./get-package-json.js";
 
-export function getCI () {
-  const { env } = process
-  const {
-    GIT_USER_NAME,
-    GIT_USER_EMAIL
-  } = env
+export function getCI() {
+  const { env } = process;
+  const { GIT_USER_NAME, GIT_USER_EMAIL } = env;
   if (env.CI) {
     if (env.GITLAB_CI) {
-      const {
-        CI_BUILD_ID,
-        CI_JOB_ID,
-        CI_COMMIT_SHA,
-        CI_COMMIT_BRANCH
-      } = env
+      const { CI_BUILD_ID, CI_JOB_ID, CI_COMMIT_SHA, CI_COMMIT_BRANCH } = env;
 
       return {
-        CI_NAME: 'GitLab CI',
-        USER: GIT_USER_NAME || 'GitLab CI',
-        EMAIL: GIT_USER_EMAIL || 'gitlab@gitlab.com',
+        CI_NAME: "GitLab CI",
+        USER: GIT_USER_NAME || "GitLab CI",
+        EMAIL: GIT_USER_EMAIL || "gitlab@gitlab.com",
         BUILD_NUMBER: CI_BUILD_ID || CI_JOB_ID,
-        CI_ORIGIN: 'origin-git',
+        CI_ORIGIN: "origin-git",
         REF_COMMIT: CI_COMMIT_SHA,
         IS_PULL_REQUEST: false,
         BRANCH_NAME: CI_COMMIT_BRANCH
-      }
+      };
     }
 
     if (env.CIRCLECI) {
-      const {
-        CIRCLE_BUILD_NUM,
-        CIRCLE_SHA1,
-        CIRCLE_PULL_REQUEST,
-        CIRCLE_BRANCH
-      } = env
+      const { CIRCLE_BUILD_NUM, CIRCLE_SHA1, CIRCLE_PULL_REQUEST, CIRCLE_BRANCH } = env;
       return {
-        CI_NAME: 'Circle CI',
-        USER: GIT_USER_NAME || 'Circle CI',
-        EMAIL: GIT_USER_EMAIL || 'circle@circleci.com',
+        CI_NAME: "Circle CI",
+        USER: GIT_USER_NAME || "Circle CI",
+        EMAIL: GIT_USER_EMAIL || "circle@circleci.com",
         BUILD_NUMBER: CIRCLE_BUILD_NUM,
-        CI_ORIGIN: 'origin-git',
+        CI_ORIGIN: "origin-git",
         REF_COMMIT: CIRCLE_SHA1,
-        IS_PULL_REQUEST: CIRCLE_PULL_REQUEST && CIRCLE_PULL_REQUEST !== 'false',
+        IS_PULL_REQUEST: CIRCLE_PULL_REQUEST && CIRCLE_PULL_REQUEST !== "false",
         BRANCH_NAME: CIRCLE_BRANCH
-      }
+      };
     }
 
     if (env.GITHUB_ACTION) {
-      const {
-        GITHUB_ACTION,
-        GITHUB_SHA,
-        GITHUB_REF,
-        GITHUB_ACTOR
-      } = env
+      const { GITHUB_ACTION, GITHUB_SHA, GITHUB_REF, GITHUB_ACTOR } = env;
       return {
-        CI_NAME: 'Github CI',
-        USER: GIT_USER_NAME || GITHUB_ACTOR || 'Github CI',
-        EMAIL: GIT_USER_EMAIL || 'action@github.com',
+        CI_NAME: "Github CI",
+        USER: GIT_USER_NAME || GITHUB_ACTOR || "Github CI",
+        EMAIL: GIT_USER_EMAIL || "action@github.com",
         BUILD_NUMBER: GITHUB_ACTION,
-        CI_ORIGIN: 'origin-git',
+        CI_ORIGIN: "origin-git",
         REF_COMMIT: GITHUB_SHA,
         IS_PULL_REQUEST: false,
-        BRANCH_NAME: GITHUB_REF.replace('refs/heads/', '')
-      }
+        BRANCH_NAME: GITHUB_REF.replace("refs/heads/", "")
+      };
     }
 
     return {
-      NAME: 'Unsupported CI',
-      BUILD_NUMBER: '',
-      CI_ORIGIN: 'origin-git',
+      NAME: "Unsupported CI",
+      BUILD_NUMBER: "",
+      CI_ORIGIN: "origin-git",
       IS_PULL_REQUEST: false,
       BRANCH_NAME: git.getBranchName()
-    }
+    };
   }
   // / local
   return {
-    NAME: 'LOCAL',
-    BUILD_NUMBER: '1',
-    CI_ORIGIN: 'origin-git',
+    NAME: "LOCAL",
+    BUILD_NUMBER: "1",
+    CI_ORIGIN: "origin-git",
     BRANCH_NAME: git.getBranchName()
-  }
+  };
 }
 
-export function getConfig () {
-  const pkg = getPackageJson()
-  const [owner, projectName] = pkg.name.replace(/^@/, '').split('/')
-  const {
-    PROJECT_NAME,
-    DOCKER_HUB_ID,
-    DOCKER_HUB_PWD,
-    REF_COMMIT,
-    GH_TOKEN,
-    HEROKU_APP,
-    SKIP_GITHUB_PUBLISH,
-    GITHUB_PAGES_PATH,
-    REPOSITORY_URL,
-    GIT_USER_NAME,
-    GIT_USER_EMAIL
-  } = process.env
+export function getConfig() {
+  const pkg = getPackageJson();
+  const [owner, projectName] = pkg.name.replace(/^@/, "").split("/");
+  const { PROJECT_NAME, DOCKER_HUB_ID, DOCKER_HUB_PWD, REF_COMMIT, GH_TOKEN, SCM_TOKEN, REPOSITORY_URL, GIT_USER_NAME, GIT_USER_EMAIL } =
+    process.env;
 
-  const HAS_YARN = hasYarn()
-  const E2E_CMD = pkg.scripts.test_e2e ? 'test_e2e' : pkg.scripts['test:e2e'] ? 'test:e2e' : undefined
-  const IS_YARN_BERRY = HAS_YARN ? fs.existsSync(join(process.cwd(), '.yamlrc.yml')) : false
-  let BUMP_METHOD = get(pkg, 'flow.bumpMethod', 'default')
+  const HAS_YARN = hasYarn();
+  const IS_YARN_BERRY = HAS_YARN ? fs.existsSync(join(process.cwd(), ".yamlrc.yml")) : false;
+  let BUMP_METHOD = get(pkg, "flow.bumpMethod", "default");
 
-  if (IS_YARN_BERRY && ['native', 'default'].includes(BUMP_METHOD)) {
-    BUMP_METHOD = 'cmflow'
+  if (IS_YARN_BERRY && ["native", "default"].includes(BUMP_METHOD)) {
+    BUMP_METHOD = "cmflow";
   }
 
   return {
+    pkg,
     PROJECT_NAME: PROJECT_NAME || projectName,
     HAS_YARN: hasYarn(),
     IS_YARN_BERRY,
     HAS_LERNA: pkg.dependencies.lerna || pkg.devDependencies.lerna,
-    HAS_BUILD: pkg.scripts.build,
-    HAS_E2E: !!E2E_CMD,
-    E2E_CMD,
-    HAS_BUILD_CHANGELOG: pkg.scripts.build_changelog,
-    get DEPLOY_ON_DOCKER () {
-      return toBool(process.env.DEPLOY_ON_DOCKER) && DOCKER_HUB_ID && DOCKER_HUB_PWD
-    },
-    get DEPLOY_ON_HEROKU () {
-      return process.env.DEPLOY_ON_HEROKU ? toBool(process.env.DEPLOY_ON_HEROKU) && !!HEROKU_APP : !!HEROKU_APP
-    },
-    CI_SKIP: '[ci skip]',
-    RELEASE_CANDIDATE_TAG: '[MEP]',
-    ORIGIN: 'origin',
-    get PRODUCTION_BRANCH () {
-      return get(pkg, 'flow.branch.production') || process.env.PRODUCTION_BRANCH || 'production'
+    CI_SKIP: "[ci skip]",
+    RELEASE_CANDIDATE_TAG: "[MEP]",
+    ORIGIN: "origin",
+    get PRODUCTION_BRANCH() {
+      return get(pkg, "flow.branch.production") || process.env.PRODUCTION_BRANCH || "production";
     },
-    get DEVELOP_BRANCH () {
-      return get(pkg, 'flow.branch.develop') || process.env.DEVELOP_BRANCH || 'master'
+    get DEVELOP_BRANCH() {
+      return get(pkg, "flow.branch.develop") || process.env.DEVELOP_BRANCH || "master";
     },
-    get OWNER () {
-      return process.env.OWNER || owner
+    get OWNER() {
+      return process.env.OWNER || owner;
     },
-    get DOCKER_REPOSITORY () {
-      const {
-        DOCKER_REPOSITORY,
-        OWNER,
-        PROJECT_NAME
-      } = process.env
-      return DOCKER_REPOSITORY || `${OWNER || owner}/${PROJECT_NAME || projectName}`
-    },
-    get SKIP_DEPLOY () {
-      return toBool(process.env.SKIP_DEPLOY)
-    },
-    get SKIP_E2E () {
-      return process.env.SKIP_E2E ? toBool(process.env.SKIP_E2E) : false
+    get DOCKER_REPOSITORY() {
+      const { DOCKER_REPOSITORY, OWNER, PROJECT_NAME } = process.env;
+      return DOCKER_REPOSITORY || `${OWNER || owner}/${PROJECT_NAME || projectName}`;
     },
     DOCKER_HUB_ID,
     DOCKER_HUB_PWD,
-    HEROKU_APP,
     REF_COMMIT,
     GH_TOKEN,
-    REPOSITORY_URL: get(pkg, 'repository.url', get(pkg, 'repository', REPOSITORY_URL)),
-    SKIP_GITHUB_PUBLISH,
-    GITHUB_PAGES_PATH,
+    SCM_TOKEN: GH_TOKEN || SCM_TOKEN,
+    REPOSITORY_URL: get(pkg, "repository.url", get(pkg, "repository", REPOSITORY_URL)),
     GIT_USER_NAME,
     GIT_USER_EMAIL,
     BUMP_METHOD,
     WORKSPACES: pkg.workspaces || [],
     ...getCI()
-  }
+  };
 }

package/src/common/get-package-json.js

@@ -1,7 +1,7 @@
-import fs from 'fs'
+import fs from "fs";
 
-export function getPackageJson () {
-  const content = fs.readFileSync(`${process.cwd()}/package.json`, { encoding: 'utf8' })
+export function getPackageJson() {
+  const content = fs.readFileSync(`${process.cwd()}/package.json`, { encoding: "utf8" });
 
-  return JSON.parse(content)
+  return JSON.parse(content);
 }

package/src/common/get-release-config.js

@@ -1,9 +1,8 @@
-export async function getReleaseConfig () {
+export async function getReleaseConfig() {
   try {
-    return await import(`${process.cwd()}/release.config.mjs`)
+    return await import(`${process.cwd()}/release.config.mjs`);
   } catch (er) {
-    // eslint-disable-next-line no-console
-    console.log('Error while loading release.config.mjs', er)
-    return {}
+    console.log("Error while loading release.config.mjs", er);
+    return {};
   }
 }

package/src/common/index.js

@@ -1,10 +1,10 @@
-export * from './cli/cli.js'
-export * from './cli/docker.js'
-export * from './cli/git.js'
-export * from './cli/lerna.js'
-export * from './cli/npm.js'
-export * from './cli/yarn.js'
-export * from './get-config.js'
-export * from './configure-git-workspace.js'
-export * from './get-package-json.js'
-export * from './run-command.js'
+export * from "./cli/cli.js";
+export * from "./cli/docker.js";
+export * from "./cli/git.js";
+export * from "./cli/lerna.js";
+export * from "./cli/npm.js";
+export * from "./cli/yarn.js";
+export * from "./configure-git-workspace.js";
+export * from "./get-config.js";
+export * from "./get-package-json.js";
+export * from "./run-command.js";

package/src/common/run-command.js

@@ -1,20 +1,21 @@
-import chalk from 'chalk'
-import figures from 'figures'
-import inquirer from 'inquirer'
-import Listr from 'listr'
-import { getReleaseConfig } from './get-release-config.js'
-import { getConfig } from './get-config.js'
+import chalk from "chalk";
+import figures from "figures";
+import inquirer from "inquirer";
+import Listr from "listr";
 
-function createTasksRunner (tasks, ctx) {
+import { getConfig } from "./get-config.js";
+import { getReleaseConfig } from "./get-release-config.js";
+
+function createTasksRunner(tasks, ctx) {
   return new Listr(tasks, {
     concurrent: false,
-    renderer: !ctx.verbose ? 'default' : 'verbose'
-  }).run(ctx)
+    renderer: !ctx.verbose ? "default" : "verbose"
+  }).run(ctx);
 }
 
-export async function runCommand (klass, commander) {
+export async function runCommand(klass, commander) {
   try {
-    const config = getConfig()
+    const config = getConfig();
     let context = {
       ...getReleaseConfig(),
       ...config,
@@ -22,45 +23,42 @@ export async function runCommand (klass, commander) {
       config,
       logger: console,
       verbose: commander.verbose
-    }
+    };
 
-    // eslint-disable-next-line new-cap
-    const command = new klass()
+    const command = new klass();
 
     // Map context from commander and current context
     if (command.mapContext) {
-      context = command.mapContext(commander, context)
+      context = command.mapContext(commander, context);
     }
 
     // show prompts
     if (command.prompt) {
       context = {
         ...context,
-        ...await inquirer.prompt(command.prompt(context))
-      }
+        ...(await inquirer.prompt(command.prompt(context)))
+      };
     }
 
     // Verify conditions
-    command.verifyConditions && command.verifyConditions(context)
+    command.verifyConditions && command.verifyConditions(context);
 
     // Get tasks
-    const tasks = command.getTasks(context)
+    const tasks = command.getTasks(context);
 
     // Run tasks
-    await createTasksRunner(tasks, context)
+    await createTasksRunner(tasks, context);
 
-    command.success && command.success(context)
+    command.success && command.success(context);
   } catch (er) {
-    // eslint-disable-next-line no-console
-    console.error(chalk.red(figures.cross + ' ' + String(er)))
+    console.error(chalk.red(figures.cross + " " + String(er)));
     if (commander.verbose) {
-      // eslint-disable-next-line no-console
-      console.error(String(er.stack).replace(String(er), ''))
+      console.error(String(er.stack).replace(String(er), ""));
     }
-    process.exit(-1)
+    process.exit(-1);
   }
 }
 
-process.on('unhandledRejection', (reason, p) => {
+process.on("unhandledRejection", () => {
   // avoid extra promise rejection when using toObservable
-})
+});

package/src/common/run-command.test.js

@@ -1,69 +1,65 @@
-import { beforeEach, describe, expect, it, jest } from '@jest/globals'
+vi.mock("listr", () => {
+  return { default: vi.fn() };
+});
 
-jest.unstable_mockModule('listr', () => {
-  return { default: jest.fn() }
-})
-const { default: Listr } = await import('listr')
-const { runCommand } = await import('./run-command.js')
+const { default: Listr } = await import("listr");
+const { runCommand } = await import("./run-command.js");
 
-describe('runCommand', () => {
+describe("runCommand", () => {
   beforeEach(() => {
     Listr.mockReturnValue({
-      run () {
-      }
-    })
-  })
-  it('should call runCommand', async () => {
+      run() {}
+    });
+  });
+  it("should call runCommand", async () => {
     class Cmd {
-      mapContext (ctx) {
+      mapContext(ctx) {
         return {
           ...ctx,
           test: true
-        }
+        };
       }
 
-      getTasks () {
-        return []
+      getTasks() {
+        return [];
       }
     }
 
-    jest.spyOn(Cmd.prototype, 'mapContext')
-    jest.spyOn(Cmd.prototype, 'getTasks')
+    vi.spyOn(Cmd.prototype, "mapContext");
+    vi.spyOn(Cmd.prototype, "getTasks");
 
     await runCommand(Cmd, {
-      prop: '1'
-    })
+      prop: "1"
+    });
 
-    expect(Cmd.prototype.mapContext).toHaveBeenCalledWith({ prop: '1' }, expect.any(Object))
+    expect(Cmd.prototype.mapContext).toHaveBeenCalledWith({ prop: "1" }, expect.any(Object));
     expect(Cmd.prototype.getTasks).toHaveBeenCalledWith({
-      prop: '1',
+      prop: "1",
       test: true
-    })
-  })
-  it('should call runCommand and catch error', async () => {
+    });
+  });
+  it("should call runCommand and catch error", async () => {
     class Cmd {
-      mapContext (ctx) {
+      mapContext(ctx) {
         return {
           ...ctx,
           test: true
-        }
+        };
       }
 
-      getTasks () {
-        throw new Error('Error')
+      getTasks() {
+        throw new Error("Error");
       }
     }
 
-    jest.spyOn(console, 'error').mockReturnValue(undefined)
-    jest.spyOn(process, 'exit').mockImplementation(() => {
-    })
+    vi.spyOn(console, "error").mockReturnValue(undefined);
+    vi.spyOn(process, "exit").mockImplementation(() => {});
 
     await runCommand(Cmd, {
-      prop: '1'
-    })
+      prop: "1"
+    });
 
-    // eslint-disable-next-line no-console
-    expect(console.error).toHaveBeenCalled()
-    expect(process.exit).toHaveBeenCalledWith(-1)
-  })
-})
+    expect(console.error).toHaveBeenCalled();
+    expect(process.exit).toHaveBeenCalledWith(-1);
+  });
+});

package/src/index.js

@@ -1 +1,10 @@
-export * from './main.js'
+import * as commands from "./commands/index.js";
+
+export * from "./commands/release.js";
+export * from "./common/index.js";
+export * from "./semantic/define-config.js";
+export * from "./semantic/utils/release-rules.js";
+export * from "./semantic/utils/transform-writer.js";
+export * from "./workflow/index.js";
+
+export { commands };

package/src/semantic/core/analyze-commits.js

@@ -0,0 +1,17 @@
+import * as commitAnalyzerPlugins from "@semantic-release/commit-analyzer";
+
+import { calculateSnapshotVersion } from "../utils/calculate-snapshot-version.js";
+
+export async function analyzeCommits(pluginConfig, context) {
+  if (context.branch && context.branch.type !== "prerelease") {
+    return commitAnalyzerPlugins.analyzeCommits(pluginConfig, context);
+  }
+
+  const analyzedCommits = await commitAnalyzerPlugins.analyzeCommits(pluginConfig, context);
+  context.nextRelease = context.nextRelease || {};
+  context.nextRelease.type = analyzedCommits;
+  context.nextRelease.version = calculateSnapshotVersion(context);
+  context.lastRelease.version = null;
+
+  return "patch";
+}

package/src/semantic/core/fail.js

@@ -0,0 +1,29 @@
+import { git } from "../../common/index.js";
+
+/**
+ * Remove the tag from the git repository if the release is not a prerelease.
+ *
+ * Add runAfter property with the semantic-release plugin name to run after the fail task.
+ *
+ * @param pluginConfig {{runAfter: string}}
+ * @param context
+ * @return {Promise<void>}
+ */
+export async function fail(pluginConfig, context) {
+  if (context.branch && context.branch.type !== "prerelease") {
+    const {
+      tagFormat,
+      config: { ORIGIN }
+    } = context;
+
+    try {
+      await git.push("--delete", ORIGIN, tagFormat.replace("${version}", context.nextRelease.version));
+    } catch {}
+
+    if (pluginConfig.runAfter) {
+      const { fail } = await import(pluginConfig.runAfter);
+
+      await fail(pluginConfig, context);
+    }
+  }
+}

package/src/semantic/core/generate-notes.js

@@ -0,0 +1,11 @@
+import * as releaseNotesPlugins from "@semantic-release/release-notes-generator";
+
+import { getConfig } from "../../common/index.js";
+
+export async function generateNotes(pluginConfig, context) {
+  context.config = getConfig();
+
+  if (context.branch.type === "release") {
+    return releaseNotesPlugins.generateNotes(pluginConfig, context);
+  }
+}

package/src/semantic/core/prepare/bump-version.js

@@ -0,0 +1,38 @@
+import { getConfig, lerna, npm, yarn } from "../../../common/index.js";
+import { bumpPackagesVersion } from "../../utils/bump-packages-version.js";
+
+export async function prepare(pluginConfig, context) {
+  context.config = getConfig();
+  const {
+    config: { HAS_YARN, HAS_LERNA, BUMP_METHOD, WORKSPACES },
+    logger
+  } = context;
+  const pkgManager = HAS_YARN ? yarn : npm;
+
+  logger.info(`Start bump version for all packages using method: ${BUMP_METHOD}`);
+
+  switch (BUMP_METHOD) {
+    case "native":
+      logger.info("Using package manager");
+      npm.newVersion(context.nextRelease.version);
+      break;
+    case "lerna":
+      if (HAS_LERNA) {
+        await lerna.newVersion(context.nextRelease.version);
+      }
+      break;
+    case "cmflow":
+      await bumpPackagesVersion(context.nextRelease.version, WORKSPACES);
+      await pkgManager.install();
+      break;
+    case "native:lerna":
+    default:
+      npm.newVersion(context.nextRelease.version);
+
+      if (HAS_LERNA) {
+        await lerna.newVersion(context.nextRelease.version);
+      }
+  }
+
+  logger.info("Bump version finished with success...");
+}

package/src/semantic/core/prepare/post.js

@@ -0,0 +1,38 @@
+import { configureGitWorkspace, getConfig, git } from "../../../common/index.js";
+
+export async function prepare(pluginConfig, context) {
+  context.config = getConfig();
+  const { branch } = context;
+
+  if (branch.type === "release") {
+    context.config = getConfig();
+
+    const {
+      logger,
+      config: { CI_NAME, BUILD_NUMBER }
+    } = context;
+
+    logger.info("Prepare release");
+
+    configureGitWorkspace(context);
+
+    logger.info("Adding files to commit");
+    git.add("-A").sync();
+
+    logger.info("Get commit stage status");
+    git.status();
+
+    const revisionMessage = `${CI_NAME} build: ${context.branch.name} ${BUILD_NUMBER} ${context.nextRelease.gitTag} [ci skip]`;
+
+    logger.info("Commit changes with revision message: ");
+    logger.info(revisionMessage);
+
+    git.commit("-m", revisionMessage).sync();
+
+    logger.success("Change committed");
+    return;
+  }
+
+  // avoid next semantic-release steps when is a prerelease or release branch with SKIP_GITHUB_PUBLISH
+  process.exit(0);
+}

package/src/semantic/core/prepare/run.js

@@ -0,0 +1,22 @@
+import { getConfig, npm, yarn } from "../../../common/index.js";
+
+/**
+ * @param pluginConfig {{command: string}}
+ * @param context
+ * @return {Promise<void>}
+ */
+export async function prepare(pluginConfig, context) {
+  context.config = getConfig();
+  const {
+    config: { HAS_YARN },
+    logger
+  } = context;
+
+  const pkgManager = HAS_YARN ? yarn : npm;
+
+  logger.info(`Start ${pluginConfig.command} task`);
+
+  await pkgManager.run(pluginConfig.command);
+
+  logger.info(`${pluginConfig.command} task finished with success...`);
+}