@cmflow/cli 2.0.7 → 2.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cmflow/cli",
-  "version": "2.0.7",
+  "version": "2.1.0",
   "description": "An awesome Git Flow",
   "author": "camfou",
   "license": "MIT",

package/src/commands/jira-releases.js

@@ -84,9 +84,10 @@ Au menu de cette livraison :
 ${context.releases
   .reverse()
   .map((release) => {
-    const issues = release.issues.map((issue) => {
-      return ` - ${TYPES[issue.fields.issuetype.name] || issue.fields.issuetype.name}(${issue.key}): ${getSummary(issue)}`;
-    });
+    const issues =
+      release.issues?.map((issue) => {
+        return ` - ${TYPES[issue.fields.issuetype.name] || issue.fields.issuetype.name}(${issue.key}): ${getSummary(issue)}`;
+      }) || [];
 
     return issues.length ? (context.releases.length > 1 ? "- v" + release.version + ":\n" : "") + issues.join(",\n") : false;
   })

package/src/commands/rebase.js

@@ -11,7 +11,6 @@ export class Rebase extends Fetch {
   mapContext(commander, context) {
     return {
       ...context,
-      useYarn: context.HAS_YARN,
       origin: context.ORIGIN,
       featureBranch: git.getBranchName(),
       fromBranch: context.PRODUCTION_BRANCH,

package/src/commands/start.js

@@ -32,7 +32,6 @@ export class Start extends Fetch {
 
     return {
       ...context,
-      useYarn: context.HAS_YARN,
       origin: context.ORIGIN,
       jiraId: options.jiraId,
       branchName: options.branchName,

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

@@ -1,18 +1,16 @@
-import { git, npm, yarn } from "../../common/index.js";
-
-export const runTest = ({ E2E_CMD, useYarn, skipTest, skipUnit, skipE2E }) => {
-  const manager = useYarn ? yarn : npm;
+import { getPackageManager, git } from "../../common/index.js";
 
+export const runTest = ({ E2E_CMD, PACKAGE_MANAGER, skipTest, skipUnit, skipE2E }) => {
   return [
     {
       title: "Unit test",
       skip: () => skipTest || skipUnit,
-      task: () => manager.run("test")
+      task: () => getPackageManager(PACKAGE_MANAGER).run("test")
     },
     {
       title: "E2E test",
       skip: () => skipTest || skipE2E,
-      task: () => manager.run(E2E_CMD || "test_e2e")
+      task: () => getPackageManager(PACKAGE_MANAGER).run(E2E_CMD || "test_e2e")
     },
     {
       title: "Reset changes",

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

@@ -1,11 +1,10 @@
 import Listr from "listr";
 import { catchError } from "rxjs";
 
-import { npm, yarn } from "../../common/index.js";
+import { getPackageManager } from "../../common/index.js";
 import { refreshMetadata, shouldReinstall } from "../utils/check-install.js";
 
-export const updateDependencies = ({ useYarn }) => {
-  const manager = useYarn ? yarn : npm;
+export const updateDependencies = ({ PACKAGE_MANAGER }) => {
   const reinstall = shouldReinstall();
 
   return {
@@ -15,14 +14,14 @@ export const updateDependencies = ({ useYarn }) => {
       new Listr(
         [
           {
-            title: `Restore dependencies using ${useYarn ? "Yarn" : "Npm"}`,
+            title: `Restore dependencies using ${PACKAGE_MANAGER.toUpperCase()}`,
             task: () =>
-              manager
+              getPackageManager(PACKAGE_MANAGER)
                 .restore()
                 .toObservable()
                 .pipe(
                   catchError((error) => {
-                    if (useYarn) {
+                    if (PACKAGE_MANAGER === "yarn") {
                       if (error.stderr.startsWith("error Your lockfile needs to be updated")) {
                         throw new Error("yarn.lock file is outdated. Run yarn, commit the updated lockfile and try again.");
                       }

package/src/common/cli/pnpm.js

@@ -0,0 +1,34 @@
+import { Cli } from "./cli.js";
+
+class PnpmCli extends Cli {
+  constructor() {
+    super("pnpm");
+  }
+
+  newVersion(version) {
+    // pnpm follows npm's version CLI semantics
+    return this.version("--no-git-tag-version", version);
+  }
+
+  version(...args) {
+    return this.sync("version", ...args);
+  }
+
+  run(...args) {
+    return super.run("run", ...args);
+  }
+
+  install(...args) {
+    return super.run("install", ...args);
+  }
+
+  /**
+   * Reinstall dependencies without pnpm-lock.yaml mutation
+   * @returns {Promise<unknown>}
+   */
+  restore() {
+    return super.run("install", "--frozen-lockfile");
+  }
+}
+
+export const pnpm = new PnpmCli();

package/src/common/cli/pnpm.test.js

@@ -0,0 +1,51 @@
+vi.mock("execa", () => {
+  const execaMock = vi.fn();
+  execaMock.sync = vi.fn();
+  return { default: execaMock };
+});
+
+const { default: execa } = await import("execa");
+const { pnpm } = await import("./pnpm.js");
+const { Cli } = await import("./cli.js");
+
+execa.sync.mockImplementation((...args) => {
+  return {
+    stdout: `CMD: ${[].concat(...args.filter((arg) => typeof arg === "string" || Array.isArray(arg))).join(" ")}`
+  };
+});
+execa.mockReturnValue({});
+
+describe("PnpmCli", () => {
+  beforeEach(() => {
+    vi.spyOn(Cli, "getRaw").mockImplementation((...args) => {
+      return `CMD: ${[].concat(...args.filter((arg) => typeof arg === "string" || Array.isArray(arg))).join(" ")}`;
+    });
+  });
+  describe("newVersion", () => {
+    it("should run newVersion cmd", () => {
+      const result = pnpm.newVersion("1.0.0");
+
+      expect(result.stdout).toEqual("CMD: pnpm version --no-git-tag-version 1.0.0");
+    });
+  });
+  describe("run", () => {
+    it('should run "run" cmd', async () => {
+      await pnpm.run("run-arg");
+
+      expect(execa).toHaveBeenCalledWith("pnpm", ["run", "run-arg"], {
+        cwd: process.cwd(),
+        stdio: "inherit"
+      });
+    });
+  });
+  describe("install", () => {
+    it('should run "install" cmd', async () => {
+      await pnpm.install("install-arg");
+
+      expect(execa).toHaveBeenCalledWith("pnpm", ["install", "install-arg"], {
+        cwd: process.cwd(),
+        stdio: "inherit"
+      });
+    });
+  });
+});

package/src/common/get-config.js

@@ -94,17 +94,20 @@ export function getConfig() {
   } = process.env;
 
   const HAS_YARN = hasYarn();
+  const HAS_PNPM = fs.existsSync(join(process.cwd(), "pnpm-lock.yaml"));
   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)) {
+  if ((IS_YARN_BERRY || HAS_PNPM) && ["native", "default"].includes(BUMP_METHOD)) {
     BUMP_METHOD = "cmflow";
   }
 
   return {
     pkg,
+    PACKAGE_MANAGER: HAS_PNPM ? "pnpm" : HAS_YARN ? "yarn" : "npm",
     PROJECT_NAME: PROJECT_NAME || projectName,
-    HAS_YARN: hasYarn(),
+    HAS_YARN,
+    HAS_PNPM,
     IS_YARN_BERRY,
     HAS_LERNA: (pkg.dependencies && pkg.dependencies.lerna) || (pkg.devDependencies && pkg.devDependencies.lerna),
     CI_SKIP: "[ci skip]",

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

@@ -0,0 +1,7 @@
+import { npm } from "./cli/npm.js";
+import { pnpm } from "./cli/pnpm.js";
+import { yarn } from "./cli/yarn.js";
+
+export function getPackageManager(pkgManager) {
+  return pkgManager === "yarn" ? yarn : pkgManager === "pnpm" ? pnpm : npm;
+}

package/src/common/index.js

@@ -3,8 +3,10 @@ export * from "./cli/docker.js";
 export * from "./cli/git.js";
 export * from "./cli/lerna.js";
 export * from "./cli/npm.js";
+export * from "./cli/pnpm.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 "./get-package-manager.js";
 export * from "./run-command.js";

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

@@ -1,20 +1,19 @@
-import { getConfig, lerna, npm, yarn } from "../../../common/index.js";
+import { getConfig, getPackageManager, lerna } from "../../../common/index.js";
 import { bumpPackagesVersion } from "../../utils/bump-packages-version.js";
 
-export async function prepare(pluginConfig, context) {
+export async function prepare(_, context) {
   context.config = getConfig();
   const {
-    config: { HAS_YARN, HAS_LERNA, BUMP_METHOD, WORKSPACES },
+    config: { PACKAGE_MANAGER, 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);
+      getPackageManager(PACKAGE_MANAGER).newVersion(context.nextRelease.version);
       break;
     case "lerna":
       if (HAS_LERNA) {
@@ -23,11 +22,11 @@ export async function prepare(pluginConfig, context) {
       break;
     case "cmflow":
       await bumpPackagesVersion(context.nextRelease.version, WORKSPACES);
-      await pkgManager.install();
+      await getPackageManager(PACKAGE_MANAGER).install();
       break;
     case "native:lerna":
     default:
-      npm.newVersion(context.nextRelease.version);
+      getPackageManager("npm").newVersion(context.nextRelease.version);
 
       if (HAS_LERNA) {
         await lerna.newVersion(context.nextRelease.version);

package/src/semantic/core/run.js

@@ -1,4 +1,4 @@
-import { getConfig, npm, yarn } from "../../common/index.js";
+import { getConfig, getPackageManager } from "../../common/index.js";
 
 /**
  * @param pluginConfig {{command: string}}
@@ -8,11 +8,11 @@ import { getConfig, npm, yarn } from "../../common/index.js";
 export default async function runCommand(pluginConfig, context) {
   context.config = getConfig();
   const {
-    config: { HAS_YARN },
+    config: { PACKAGE_MANAGER },
     logger
   } = context;
 
-  const pkgManager = HAS_YARN ? yarn : npm;
+  const pkgManager = getPackageManager(PACKAGE_MANAGER);
 
   logger.info(`Start ${pluginConfig.command} task`);