@cmflow/cli 1.1.0 → 2.0.0-alpha.1

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/conditional.js

@@ -0,0 +1,25 @@
+import { getConfig } from "../../common/index.js";
+export function success(pluginConfig, context) {
+  return runAll(pluginConfig, context, context.branch?.type === "release");
+}
+
+export function publish(pluginConfig, context) {
+  return runAll(pluginConfig, context, context.branch?.type === "release");
+}
+
+export function fail(pluginConfig, context) {
+  return runAll(pluginConfig, context, context.branch?.type === "release");
+}
+
+async function runAll(pluginConfig, context, defaultCondition) {
+  context.config = getConfig();
+
+  const condition = pluginConfig.when !== undefined ? pluginConfig.if(context) : defaultCondition;
+
+  if (condition && pluginConfig.run) {
+    const tasks = [].concat(pluginConfig.run);
+    for (const task of tasks) {
+      await task(pluginConfig, context);
+    }
+  }
+}

package/src/semantic/core/fail.js

@@ -0,0 +1,21 @@
+import { git } from "../../common/index.js";
+
+/**
+ * Remove the tag from the git repository if the release is not a prerelease.
+ *
+ * @param pluginConfig
+ * @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 {}
+  }
+}

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...`);
+}

package/src/semantic/core/success.js

@@ -0,0 +1,33 @@
+import { getConfig } from "../../common/get-config.js";
+import { git } from "../../common/index.js";
+
+/**
+ * Add runAfter property with the semantic-release plugin name to run after the success task
+ * depending on the branch type.
+ *
+ * @param pluginConfig {{}}
+ * @param context
+ * @return {Promise<void>}
+ */
+export async function success(pluginConfig, context) {
+  context.config = getConfig();
+  const {
+    branch,
+    logger,
+    config: { PRODUCTION_BRANCH, ORIGIN, DEVELOP_BRANCH }
+  } = context;
+
+  const condition = pluginConfig.when !== undefined ? pluginConfig.when(context) : branch.type !== "prerelease";
+
+  if (condition) {
+    await git.push("--quiet", "--set-upstream", ORIGIN, PRODUCTION_BRANCH);
+
+    if (PRODUCTION_BRANCH !== DEVELOP_BRANCH) {
+      logger.start(`Reset HEAD of ${ORIGIN}/${DEVELOP_BRANCH} branch to HEAD of  ${ORIGIN}/${PRODUCTION_BRANCH} `);
+
+      await git.push("-f", ORIGIN, `refs/remotes/${ORIGIN}/${PRODUCTION_BRANCH}:refs/heads/${DEVELOP_BRANCH}`);
+
+      logger.success(`${ORIGIN}/${DEVELOP_BRANCH} branch correctly updated`);
+    }
+  }
+}

package/src/semantic/core/verify-conditions.js

@@ -0,0 +1,32 @@
+import chalk from "chalk";
+
+import { getConfig, git } from "../../common/index.js";
+
+export function verifyConditions(pluginConfig, context) {
+  if (pluginConfig.dryRun) {
+    return;
+  }
+
+  context.config = getConfig();
+  const {
+    branch,
+    config: { USER, EMAIL, ORIGIN }
+  } = context;
+
+  if (USER && EMAIL) {
+    context.logger.info("Configure git with username");
+
+    git.config("--global", "user.name", USER);
+    git.config("--global", "user.email", EMAIL);
+
+    context.logger.info("Configure git branch");
+    context.logger.success("Workspace is correctly configured");
+  } else {
+    context.logger.error(chalk.red("Ignore git configuration (Empty GIT_USER_EMAIL or/and GIT_USER_NAME variables)"));
+    process.exit(1);
+  }
+
+  git.fetch().sync();
+  git.checkout(branch.name).sync();
+  git.branch(`--set-upstream-to=${ORIGIN}/${branch.name}`, branch.name).sync();
+}

package/src/semantic/core/verify-release.js

@@ -0,0 +1,9 @@
+import { getConfig } from "../../common/index.js";
+import { displayPackageInfo } from "../utils/display-package-info.js";
+import { displayReleaseInfo } from "../utils/display-release-info.js";
+
+export function verifyRelease(pluginConfig, context) {
+  context.config = getConfig();
+  displayPackageInfo(context);
+  displayReleaseInfo(context);
+}

package/src/semantic/define-config.js

@@ -0,0 +1,68 @@
+import { getConfig } from "../common/get-config.js";
+import { releaseRules } from "./utils/release-rules.js";
+import { transformWriter } from "./utils/transform-writer.js";
+
+/**
+ * Define the semantic-release configuration based on the ClubMed API configuration.
+ * @param {import('semantic-release').GlobalConfig} opts
+ * @returns {import('semantic-release').GlobalConfig}
+ */
+export function defineConfig(opts = {}) {
+  const { PRODUCTION_BRANCH: productBranch, BRANCH_NAME: branchName } = getConfig();
+
+  return {
+    noCi: productBranch !== branchName,
+    branches: [
+      {
+        name: productBranch,
+        channel: "release"
+      },
+      // Use this hack to always run semantic-release (as prerelease for feature/fix branch)
+      {
+        name: branchName,
+        channel: "prerelease",
+        prerelease: true
+      }
+    ],
+    verifyConditions: ["@cmflow/cli/semantic/verify-conditions"],
+    analyzeCommits: ["@cmflow/cli/semantic/analyze-commits"],
+    verifyRelease: ["@cmflow/cli/semantic/verify-release"],
+    generateNotes: ["@cmflow/cli/semantic/generate-notes"],
+    prepare: [
+      "@cmflow/cli/semantic/prepare/bump-version",
+      // '@cmflow/cli/semantic/prepare/build',
+      // '@cmflow/cli/semantic/prepare/e2e',
+      "@cmflow/cli/semantif/prepare/post" // need to avoid semantic next step
+    ],
+    publish: [
+      [
+        "@cmflow/cli/semantic/publish",
+        {
+          runAfter: opts.runAfter
+        }
+      ]
+    ],
+    success: [
+      [
+        "@cmflow/cli/semantic/success",
+        {
+          runAfter: opts.runAfter
+        }
+      ]
+    ],
+    fail: [
+      [
+        "@cmflow/cli/semantic/fail",
+        {
+          runAfter: opts.runAfter
+        }
+      ]
+    ],
+    releaseRules,
+    parserOpts: {
+      noteKeywords: ["BREAKING CHANGE", "BREAKING CHANGES"]
+    },
+    writerOpts: { transform: transformWriter },
+    ...opts
+  };
+}

package/src/semantic/docker/publish.js

@@ -0,0 +1,5 @@
+import { dockerPublish } from "../utils/docker-publish.js";
+
+export async function publish(pluginConfig, context) {
+  await dockerPublish(context);
+}

package/src/semantic/docker/success.js

@@ -0,0 +1,9 @@
+import { dockerCleanTags } from "../utils/docker-clean-tags.js";
+
+export async function success(pluginConfig, context) {
+  try {
+    await dockerCleanTags(context);
+  } catch (er) {
+    context.logger.warn(er);
+  }
+}

package/src/semantic/utils/bump-packages-version.js

@@ -0,0 +1,52 @@
+import fs from "fs-extra";
+import globby from "globby";
+import { dirname } from "path";
+
+const PACKAGE_JSON_PROPS = ["dependencies", "devDependencies", "peerDependencies"];
+
+export async function bumpPackagesVersion(version, workspaces, cwd = process.cwd()) {
+  const patterns = workspaces.map((path) => `${path}/package.json`).concat("package.json");
+
+  const files = await globby(patterns, {
+    cwd,
+    absolute: true
+  });
+
+  const names = new Set();
+
+  const packages = await Promise.all(
+    files.map(async (file) => {
+      const pkg = await fs.readJson(file);
+
+      names.add(pkg.name);
+
+      return {
+        file,
+        pkg
+      };
+    })
+  );
+
+  return Promise.all(
+    packages.map(({ pkg, file }) => {
+      pkg.version = version;
+
+      PACKAGE_JSON_PROPS.forEach((key) => bumpDependencies(pkg, key, version, names));
+
+      fs.ensureDirSync(dirname(file));
+      return fs.writeFile(file, JSON.stringify(pkg, null, 2), { encoding: "utf8" });
+    })
+  );
+}
+
+function bumpDependencies(pkg, key, version, names) {
+  pkg[key] = pkg[key] || {};
+
+  if (pkg[key]) {
+    names.forEach((name) => {
+      if (pkg[key][name] && !pkg[key][name].startsWith("workspace:")) {
+        pkg[key][name] = version;
+      }
+    });
+  }
+}