@cmflow/cli 1.0.16 → 1.1.1-alpha.1

package/src/semantic/core/publish.js

@@ -0,0 +1,9 @@
+export async function publish(pluginConfig, context) {
+  const { branch } = context;
+
+  if (branch.type === "release" && pluginConfig.runAfter) {
+    const { publish } = await import(pluginConfig.runAfter);
+
+    await publish(pluginConfig, context);
+  }
+}

package/src/semantic/core/success.js

@@ -0,0 +1,37 @@
+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 {{runAfter: string}}
+ * @param context
+ * @return {Promise<void>}
+ */
+export async function success(pluginConfig, context) {
+  context.config = getConfig();
+  const {
+    branch,
+    logger,
+    config: { PRODUCTION_BRANCH, ORIGIN, DEVELOP_BRANCH }
+  } = context;
+
+  if (branch.type !== "prerelease") {
+    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`);
+    }
+
+    if (pluginConfig.runAfter) {
+      const { success } = await import(pluginConfig.runAfter);
+
+      await success(pluginConfig, context);
+    }
+  }
+}

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

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

@@ -0,0 +1,75 @@
+import fs from "fs-extra";
+import path from "path";
+import * as url from "url";
+
+import { bumpPackagesVersion } from "./bump-packages-version.js";
+
+const __dirname = url.fileURLToPath(new URL(".", import.meta.url));
+
+describe("bumpPackagesVersion()", () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+    vi.spyOn(fs, "writeFile").mockResolvedValue();
+    vi.spyOn(fs, "ensureDirSync").mockResolvedValue();
+  });
+
+  it("should upgrade dependencies (package manager: npm/yarn)", async () => {
+    await bumpPackagesVersion("1.1.0", ["packages/*"], path.join(__dirname, "__mock__/test1"));
+
+    const calls = fs.writeFile.mock.calls.sort(([a], [b]) => (a > b ? -1 : 1));
+
+    expect(JSON.parse(calls[0][1])).toEqual({
+      version: "1.1.0",
+      name: "@package/b",
+      dependencies: {},
+      devDependencies: {},
+      peerDependencies: {}
+    });
+
+    expect(JSON.parse(calls[1][1])).toEqual({
+      name: "@package/a",
+      version: "1.1.0",
+      dependencies: { "@package/b": "1.1.0" },
+      devDependencies: {},
+      peerDependencies: {}
+    });
+
+    expect(JSON.parse(calls[2][1])).toEqual({
+      name: "@package/root",
+      version: "1.1.0",
+      dependencies: {},
+      devDependencies: {},
+      peerDependencies: {}
+    });
+  });
+  it("should upgrade dependencies (package manager: yarn berry)", async () => {
+    await bumpPackagesVersion("1.1.0", ["packages/*"], path.join(__dirname, "__mock__/test2"));
+    const calls = fs.writeFile.mock.calls.sort(([a], [b]) => (a > b ? -1 : 1));
+
+    expect(JSON.parse(calls[0][1])).toEqual({
+      dependencies: {},
+      devDependencies: {},
+      name: "@package/b",
+      peerDependencies: {},
+      version: "1.1.0"
+    });
+
+    expect(JSON.parse(calls[1][1])).toEqual({
+      dependencies: {
+        "@package/b": "workspace:*"
+      },
+      devDependencies: {},
+      name: "@package/a",
+      peerDependencies: {},
+      version: "1.1.0"
+    });
+
+    expect(JSON.parse(calls[2][1])).toEqual({
+      dependencies: {},
+      devDependencies: {},
+      name: "@package/root",
+      peerDependencies: {},
+      version: "1.1.0"
+    });
+  });
+});

package/src/semantic/utils/calculate-snapshot-version.js

@@ -0,0 +1,15 @@
+import semver from "semver";
+
+import { getConfig, git } from "../../common/index.js";
+
+export function calculateSnapshotVersion(context) {
+  context.config = getConfig();
+  const {
+    nextRelease: { type },
+    lastRelease,
+    config: { REF_COMMIT }
+  } = context;
+  const { major, minor, patch } = semver.parse(lastRelease.version);
+
+  return `${semver.inc(`${major}.${minor}.${patch}`, type)}-beta${git.getCommitTag(REF_COMMIT)}`;
+}

package/src/semantic/utils/calculate-snapshot-version.test.js

@@ -0,0 +1,67 @@
+vi.mock("../../common/index.js", () => {
+  return {
+    git: {
+      getCommitTag: vi.fn()
+    },
+    getConfig: vi.fn()
+  };
+});
+const { git, getConfig } = await import("../../common/index.js");
+const { calculateSnapshotVersion } = await import("./calculate-snapshot-version.js");
+
+describe("calculateSnapshotVersion", () => {
+  beforeEach(() => {
+    git.getCommitTag.mockReturnValue("13246u");
+    getConfig.mockReturnValue({
+      DEPLOY_ON_DOCKER: true,
+      PRODUCTION_BRANCH: "production",
+      DOCKER_REPOSITORY: "owner",
+      DOCKER_HUB_ID: "login",
+      DOCKER_HUB_PWD: "password"
+    });
+  });
+  it("should return the snapshot version", () => {
+    const context = {
+      nextRelease: { type: "patch" },
+      lastRelease: {
+        version: "1.0.0"
+      }
+    };
+
+    const version = calculateSnapshotVersion(context);
+    expect(git.getCommitTag).toHaveBeenCalledWith(context.config.REF_COMMIT);
+    expect(version).toEqual("1.0.1-beta13246u");
+  });
+
+  it("should return the snapshot version", () => {
+    const context = {
+      nextRelease: { type: "minor" },
+      lastRelease: {
+        version: "1.0.0"
+      },
+      config: {
+        REF_COMMIT: "REF_COMMIT"
+      }
+    };
+
+    const version = calculateSnapshotVersion(context);
+    expect(git.getCommitTag).toHaveBeenCalledWith(context.config.REF_COMMIT);
+    expect(version).toEqual("1.1.0-beta13246u");
+  });
+
+  it("should return the snapshot version", () => {
+    const context = {
+      nextRelease: { type: "major" },
+      lastRelease: {
+        version: "1.0.0"
+      },
+      config: {
+        REF_COMMIT: "REF_COMMIT"
+      }
+    };
+
+    const version = calculateSnapshotVersion(context);
+    expect(git.getCommitTag).toHaveBeenCalledWith(context.config.REF_COMMIT);
+    expect(version).toEqual("2.0.0-beta13246u");
+  });
+});

package/src/semantic/utils/display-package-info.js

@@ -0,0 +1,11 @@
+import { logSection } from "./log-section.js";
+
+export function displayPackageInfo(context) {
+  logSection("Package Info", context);
+  context.logger.info("Name       : " + context.config.PROJECT_NAME);
+  context.logger.info("Version    : " + context.lastRelease.version);
+  context.logger.info("Repository : " + context.config.REPOSITORY_URL);
+  context.logger.info("Branch     : " + context.branch.name);
+  context.logger.info("Tag        : " + context.lastRelease.gitTag);
+  context.logger.info("GitHead    : " + context.lastRelease.gitHead);
+}

package/src/semantic/utils/display-release-info.js

@@ -0,0 +1,12 @@
+import { logSection } from "./log-section.js";
+
+export function displayReleaseInfo(context) {
+  logSection("Release Info", context);
+  context.logger.info("Branch   : " + context.branch.name);
+  context.logger.info("Build N° : " + context.config.BUILD_NUMBER);
+  context.logger.info("Version  : " + context.nextRelease.version);
+  context.logger.info("Tag      : " + context.nextRelease.gitTag);
+  context.logger.info("GitHead  : " + context.nextRelease.gitHead);
+  context.logger.info("Type     : " + context.nextRelease.type);
+  context.logger.info("Channel  : " + context.nextRelease.channel);
+}

package/src/semantic/utils/docker-clean-tags.js

@@ -0,0 +1,51 @@
+import { docker } from "../../common/index.js";
+
+function mapTags(tags) {
+  tags = tags
+    .map((tag) => {
+      return {
+        name: tag.name,
+        date: new Date(tag.last_updated).getTime()
+      };
+    })
+    .sort((a, b) => b.date - a.date);
+
+  let tagFound = false;
+
+  return tags.reduce((result, tag) => {
+    if (tag.name.match(/\d+\.\d+\.\d+/)) {
+      tagFound = true;
+    } else if (tagFound) {
+      result.push(tag);
+    }
+    return result;
+  }, []);
+}
+
+export async function dockerCleanTags(context) {
+  const {
+    logger,
+    config: { DOCKER_HUB_ID, DOCKER_HUB_PWD, DOCKER_REPOSITORY }
+  } = context;
+
+  if (DOCKER_HUB_ID && DOCKER_HUB_PWD) {
+    logger.info("Start clean Docker Hub...");
+
+    const token = await docker.getToken(DOCKER_HUB_ID, DOCKER_HUB_PWD);
+    const options = {
+      token,
+      repository: DOCKER_REPOSITORY
+    };
+
+    const tags = mapTags(await docker.getTags(options));
+
+    await Promise.all(
+      tags.map(async (tag) => {
+        await docker.deleteTag(tag.name, options);
+        logger.info(`TAG : ${tag.name} deleted`);
+      })
+    );
+
+    logger.info("Docker Hub Clean !");
+  }
+}

package/src/semantic/utils/docker-clean-tags.test.js

@@ -0,0 +1,61 @@
+vi.mock("../../common", () => {
+  return {
+    docker: {
+      getToken: vi.fn(),
+      getTags: vi.fn(),
+      deleteTag: vi.fn()
+    }
+  };
+});
+const { docker } = await import("../../common/index.js");
+const { dockerCleanTags } = await import("./docker-clean-tags.js");
+
+describe("dockerCleanTags", () => {
+  beforeEach(() => {
+    docker.getToken.mockReturnValue("token");
+    docker.getTags.mockReturnValue([
+      {
+        name: "branch-1",
+        last_updated: new Date("2020-06-01")
+      },
+      {
+        name: "1.1.0",
+        last_updated: new Date("2020-05-20")
+      },
+      {
+        name: "branch-2",
+        last_updated: new Date("2020-05-01")
+      },
+      {
+        name: "1.0.0",
+        last_updated: new Date("2020-04-01")
+      }
+    ]);
+  });
+  it("should clean obsolete tags", async () => {
+    const context = {
+      logger: {
+        info: vi.fn(),
+        warn: vi.fn()
+      },
+      config: {
+        DOCKER_HUB_ID: "DOCKER_HUB_ID",
+        DOCKER_HUB_PWD: "DOCKER_HUB_PWD",
+        DOCKER_REPOSITORY: "DOCKER_REPOSITORY"
+      }
+    };
+
+    await dockerCleanTags(context);
+
+    expect(docker.getToken).toHaveBeenCalledWith("DOCKER_HUB_ID", "DOCKER_HUB_PWD");
+    expect(docker.getTags).toHaveBeenCalledWith({
+      token: "token",
+      repository: "DOCKER_REPOSITORY"
+    });
+    expect(docker.deleteTag).toHaveBeenCalledWith("branch-2", {
+      token: "token",
+      repository: "DOCKER_REPOSITORY"
+    });
+    expect(docker.deleteTag).toHaveBeenCalledTimes(1);
+  });
+});

package/src/semantic/utils/docker-publish.js

@@ -0,0 +1,23 @@
+import { docker } from "../../common/cli/docker.js";
+import { getConfig } from "../../common/get-config.js";
+
+export async function dockerPublish(context) {
+  context.config = getConfig();
+  const {
+    logger,
+    config: { PRODUCTION_BRANCH, DOCKER_REPOSITORY, DOCKER_HUB_ID, DOCKER_HUB_PWD }
+  } = context;
+
+  docker.login("-u", DOCKER_HUB_ID, "-p", DOCKER_HUB_PWD);
+
+  const image =
+    PRODUCTION_BRANCH === context.branch.name
+      ? `${DOCKER_REPOSITORY}:${context.nextRelease.version}`
+      : `${DOCKER_REPOSITORY}:${context.branch.name}`;
+  logger.info("context.branch.name : ", context.branch.name);
+  logger.info("context.nextRelease.version : ", context.nextRelease && context.nextRelease.version);
+  logger.info("PRODUCTION_BRANCH : ", PRODUCTION_BRANCH);
+  docker.tag(`${DOCKER_REPOSITORY}:latest`, image);
+
+  await docker.push(image);
+}

package/src/semantic/utils/docker-publish.test.js

@@ -0,0 +1,44 @@
+import { docker } from "../../common/cli/docker.js";
+import { getConfig } from "../../common/get-config.js";
+import { dockerPublish } from "./docker-publish.js";
+
+vi.mock("../../common/cli/docker.js", () => {
+  return {
+    docker: {
+      login: vi.fn(),
+      tag: vi.fn(),
+      push: vi.fn()
+    }
+  };
+});
+
+vi.mock("../../common/get-config.js", () => {
+  return {
+    getConfig: vi.fn()
+  };
+});
+
+describe("dockerPublish", () => {
+  it("should publish docker image", async () => {
+    getConfig.mockReturnValue({
+      PRODUCTION_BRANCH: "production",
+      DOCKER_REPOSITORY: "owner",
+      DOCKER_HUB_ID: "login",
+      DOCKER_HUB_PWD: "password"
+    });
+    const context = {
+      logger: {
+        info: vi.fn(),
+        warn: vi.fn()
+      },
+      branch: {
+        name: "branch-name"
+      }
+    };
+    await dockerPublish(context);
+
+    expect(docker.login).toHaveBeenCalledWith("-u", "login", "-p", "password");
+    expect(docker.tag).toHaveBeenCalledWith("owner:latest", "owner:branch-name");
+    expect(docker.push).toHaveBeenCalledWith("owner:branch-name");
+  });
+});

package/src/semantic/utils/log-section.js

@@ -0,0 +1,5 @@
+export function logSection(title, context) {
+  context.logger.info("-----------------------------------");
+  context.logger.info(`--- ${title}`);
+  context.logger.info("-----------------------------------");
+}

package/src/semantic/utils/release-rules.js

@@ -0,0 +1,5 @@
+import omit from "lodash/omit.js";
+
+import { WORKFLOW_CONFIGURATION } from "../../workflow/index.js";
+
+export const releaseRules = WORKFLOW_CONFIGURATION.map((props) => omit(props, ["label"]));

package/src/semantic/utils/transform-writer.js

@@ -0,0 +1,75 @@
+import { WORKFLOW_CONFIGURATION } from "../../workflow/index.js";
+
+const commitTypeMapping = WORKFLOW_CONFIGURATION.reduce((obj, { type, label }) => {
+  return {
+    ...obj,
+    [type]: label
+  };
+}, {});
+
+const transformCommitType = (commit) => {
+  if (commitTypeMapping[commit.type]) {
+    return commitTypeMapping[commit.type];
+  }
+
+  return commitTypeMapping.default;
+};
+
+export function transformWriter(commit, context) {
+  const issues = [];
+
+  commit.notes.forEach((note) => {
+    note.title = "BREAKING CHANGES";
+  });
+
+  commit.type = transformCommitType(commit);
+
+  if (commit.message && commit.message.match(/^[\w-]+$/i)) {
+    return;
+  }
+
+  if (commit.subject) {
+    commit.subject = commit.subject.replace("[MEP]", "");
+  }
+
+  if (commit.scope === "*") {
+    commit.scope = "";
+  }
+
+  if (typeof commit.hash === "string") {
+    commit.shortHash = commit.hash.substring(0, 7);
+  }
+
+  if (typeof commit.subject === "string") {
+    let url = context.repository ? `${context.host}/${context.owner}/${context.repository}` : context.repoUrl;
+    if (url) {
+      url = `${url}/issues/`;
+      // Issue URLs.
+      commit.subject = commit.subject.replace(/#([0-9]+)/g, (_, issue) => {
+        issues.push(issue);
+        return `[#${issue}](${url}${issue})`;
+      });
+    }
+    if (context.host) {
+      // User URLs.
+      commit.subject = commit.subject.replace(/\B@([a-z0-9](?:-?[a-z0-9/]){0,38})/g, (_, username) => {
+        if (username.includes("/")) {
+          return `@${username}`;
+        }
+
+        return `[@${username}](${context.host}/${username})`;
+      });
+    }
+  }
+
+  // remove references that already appear in the subject
+  commit.references = commit.references.filter((reference) => {
+    if (issues.indexOf(reference.issue) === -1) {
+      return true;
+    }
+
+    return false;
+  });
+
+  return commit;
+}