@cmflow/cli 3.3.0 → 3.4.0-alpha.1

package/src/common/cli/{git.test.js → git.test.ts}

@@ -1,23 +1,31 @@
+import execa from "execa";
+import { Cli } from "./cli.js";
+import { git } from "./git.js";
+
 vi.mock("execa", () => {
-  const execaMock = vi.fn();
-  execaMock.sync = vi.fn();
+  const sync = vi.fn();
+  const execaMock = Object.assign(vi.fn(), { sync });
   return { default: execaMock };
 });
-const { default: execa } = await import("execa");
-const { git } = await import("./git.js");
-const { Cli } = await import("./cli.js");
-execa.sync.mockImplementation((...args) => {
+
+type ExecaMock = {
+  sync: { mockImplementation(fn: (...args: unknown[]) => unknown): void };
+  mockReturnValue(v: unknown): void;
+};
+
+const execaMock = execa as unknown as ExecaMock;
+
+execaMock.sync.mockImplementation((...args) => {
   return {
-    stdout: `CMD: ${[].concat(...args.filter((arg) => typeof arg === "string" || Array.isArray(arg))).join(" ")}`
+    stdout: `CMD: ${([] as unknown[]).concat(...(args as (string | string[])[]).filter((arg) => typeof arg === "string" || Array.isArray(arg))).join(" ")}`
   };
 });
-
-execa.mockReturnValue({});
+execaMock.mockReturnValue({});
 
 describe("GitCli", () => {
   beforeEach(() => {
-    vi.spyOn(Cli, "getRaw").mockImplementation((...args) => {
-      return `CMD: ${[].concat(...args.filter((arg) => typeof arg === "string" || Array.isArray(arg))).join(" ")}`;
+    vi.spyOn(Cli, "getRaw").mockImplementation((...args: unknown[]) => {
+      return `CMD: ${([] as unknown[]).concat(...(args as (string | string[])[]).filter((arg) => typeof arg === "string" || Array.isArray(arg))).join(" ")}`;
     });
   });
   describe("init", () => {

package/src/common/cli/{git.js → git.ts}

@@ -5,59 +5,59 @@ class GitCli extends Cli {
     super("git");
   }
 
-  init(...args) {
+  init(...args: string[]) {
     return this.run("init", ...args);
   }
 
-  add(...args) {
+  add(...args: string[]) {
     return this.run("add", ...args);
   }
 
-  status(...args) {
+  status(...args: string[]) {
     return this.sync("status", ...args);
   }
 
-  branch(...args) {
+  branch(...args: string[]) {
     return this.run("branch", ...args);
   }
 
-  clean(...args) {
+  clean(...args: string[]) {
     return this.run("clean", ...args);
   }
 
-  config(...args) {
+  config(...args: string[]) {
     return this.run("config", ...args).get();
   }
 
-  checkout(...args) {
+  checkout(...args: string[]) {
     return this.run("checkout", ...args);
   }
 
-  commit(...args) {
+  commit(...args: string[]) {
     return this.run("commit", ...args);
   }
 
-  fetch(...args) {
+  fetch(...args: string[]) {
     return this.run("fetch", ...args);
   }
 
-  prune(...args) {
+  prune(...args: string[]) {
     return this.run("prune", ...args);
   }
 
-  merge(...args) {
+  merge(...args: string[]) {
     return this.sync("merge", ...args);
   }
 
-  reset(...args) {
+  reset(...args: string[]) {
     return this.sync("reset", ...args);
   }
 
-  remote(...args) {
+  remote(...args: string[]) {
     return this.run("remote", ...args);
   }
 
-  rebase(...args) {
+  rebase(...args: string[]) {
     return this.run("rebase", ...args);
   }
 
@@ -73,20 +73,20 @@ class GitCli extends Cli {
     return this.get("log", "-1", "--pretty=%B");
   }
 
-  push(...args) {
+  push(...args: string[]) {
     return this.run("push", ...args);
   }
 
-  branchExists(branch, origin = "origin") {
-    return this.branch("-a").getRaw().trim().includes(`remotes/${origin}/${branch}`);
+  branchExists(branch: string, origin = "origin") {
+    return this.run("branch", "-a").getRaw().trim().includes(`remotes/${origin}/${branch}`);
   }
 
-  checkBranchRemoteStatus(branch, origin = "origin") {
+  checkBranchRemoteStatus(branch: string, origin = "origin") {
     return this.run("cherry", branch, `${origin}/${branch}`).get();
   }
 
-  branches(...args) {
-    return this.branch(...args)
+  branches(...args: string[]) {
+    return this.run("branch", ...args)
       .get()
       .split("\n")
       .map((branch) => branch.trim().replace("* ", ""))
@@ -94,11 +94,11 @@ class GitCli extends Cli {
       .filter((branch) => !String(branch).includes("/HEAD"));
   }
 
-  show(branch) {
+  show(branch: string) {
     return this.run("show", '--format="%ci|%cr|%an"', branch, "--").getRaw().split("\n")[0].trim();
   }
 
-  branchesInfos(...args) {
+  branchesInfos(...args: string[]) {
     return this.branches(...args)
       .map((branch) => {
         try {
@@ -113,8 +113,8 @@ class GitCli extends Cli {
           return undefined;
         }
       })
-      .filter((b) => !!b)
-      .sort((info1, info2) => info1.date < info2.date);
+      .filter((b): b is { branch: string; date: string; creation: string; author: string } => !!b)
+      .sort((info1, info2) => (info1.date < info2.date ? 1 : -1));
   }
 }
 

package/src/common/cli/{lerna.test.js → lerna.test.ts}

@@ -1,24 +1,31 @@
+import execa from "execa";
+import { lerna } from "./lerna.js";
+import { Cli } from "./cli.js";
+
 vi.mock("execa", () => {
-  const execaMock = vi.fn();
-  execaMock.sync = vi.fn();
+  const sync = vi.fn();
+  const execaMock = Object.assign(vi.fn(), { sync });
   return { default: execaMock };
 });
-const { default: execa } = await import("execa");
-const { lerna } = await import("./lerna.js");
-const { Cli } = await import("./cli.js");
 
-execa.sync.mockImplementation((...args) => {
+type ExecaMock = {
+  sync: { mockImplementation(fn: (...args: unknown[]) => unknown): void };
+  mockReturnValue(v: unknown): void;
+};
+
+const execaMock = execa as unknown as ExecaMock;
+
+execaMock.sync.mockImplementation((...args) => {
   return {
-    stdout: `CMD: ${[].concat(...args.filter((arg) => typeof arg === "string" || Array.isArray(arg))).join(" ")}`
+    stdout: `CMD: ${([] as unknown[]).concat(...(args as (string | string[])[]).filter((arg) => typeof arg === "string" || Array.isArray(arg))).join(" ")}`
   };
 });
-
-execa.mockReturnValue({});
+execaMock.mockReturnValue({});
 
 describe("LernaCli", () => {
   beforeEach(() => {
-    vi.spyOn(Cli, "getRaw").mockImplementation((...args) => {
-      return `CMD: ${[].concat(...args.filter((arg) => typeof arg === "string" || Array.isArray(arg))).join(" ")}`;
+    vi.spyOn(Cli, "getRaw").mockImplementation((...args: unknown[]) => {
+      return `CMD: ${([] as unknown[]).concat(...(args as (string | string[])[]).filter((arg) => typeof arg === "string" || Array.isArray(arg))).join(" ")}`;
     });
   });
   describe("newVersion", () => {

package/src/common/cli/{lerna.js → lerna.ts}

@@ -5,19 +5,19 @@ class LernaCli extends Cli {
     super("lerna");
   }
 
-  newVersion(version) {
+  newVersion(version: string) {
     return this.version(version, "--exact", "--yes", "--no-git-tag-version", "--no-push");
   }
 
-  version(...args) {
+  version(...args: string[]) {
     return this.sync("version", ...args);
   }
 
-  run(...args) {
+  run(...args: string[]) {
     return super.run("run", ...args);
   }
 
-  install(...args) {
+  install(...args: string[]) {
     return super.run("install", ...args);
   }
 }

package/src/common/cli/{npm.test.js → npm.test.ts}

@@ -1,24 +1,31 @@
+import execa from "execa";
+import { npm } from "./npm.js";
+import { Cli } from "./cli.js";
+
 vi.mock("execa", () => {
-  const execaMock = vi.fn();
-  execaMock.sync = vi.fn();
+  const sync = vi.fn();
+  const execaMock = Object.assign(vi.fn(), { sync });
   return { default: execaMock };
 });
 
-const { default: execa } = await import("execa");
-const { npm } = await import("./npm.js");
-const { Cli } = await import("./cli.js");
+type ExecaMock = {
+  sync: { mockImplementation(fn: (...args: unknown[]) => unknown): void };
+  mockReturnValue(v: unknown): void;
+};
+
+const execaMock = execa as unknown as ExecaMock;
 
-execa.sync.mockImplementation((...args) => {
+execaMock.sync.mockImplementation((...args) => {
   return {
-    stdout: `CMD: ${[].concat(...args.filter((arg) => typeof arg === "string" || Array.isArray(arg))).join(" ")}`
+    stdout: `CMD: ${([] as unknown[]).concat(...(args as (string | string[])[]).filter((arg) => typeof arg === "string" || Array.isArray(arg))).join(" ")}`
   };
 });
-execa.mockReturnValue({});
+execaMock.mockReturnValue({});
 
 describe("NpmCli", () => {
   beforeEach(() => {
-    vi.spyOn(Cli, "getRaw").mockImplementation((...args) => {
-      return `CMD: ${[].concat(...args.filter((arg) => typeof arg === "string" || Array.isArray(arg))).join(" ")}`;
+    vi.spyOn(Cli, "getRaw").mockImplementation((...args: unknown[]) => {
+      return `CMD: ${([] as unknown[]).concat(...(args as (string | string[])[]).filter((arg) => typeof arg === "string" || Array.isArray(arg))).join(" ")}`;
     });
   });
   describe("newVersion", () => {

package/src/common/cli/{npm.js → npm.ts}

@@ -5,19 +5,19 @@ class NpmCli extends Cli {
     super("npm");
   }
 
-  newVersion(version) {
+  newVersion(version: string) {
     return this.version("--no-git-tag-version", version);
   }
 
-  version(...args) {
+  version(...args: string[]) {
     return this.sync("version", ...args);
   }
 
-  run(...args) {
+  run(...args: string[]) {
     return super.run("run", ...args);
   }
 
-  install(...args) {
+  install(...args: string[]) {
     return super.run("install", ...args);
   }
 

package/src/common/cli/{pnpm.test.js → pnpm.test.ts}

@@ -1,24 +1,31 @@
+import execa from "execa";
+import { pnpm } from "./pnpm.js";
+import { Cli } from "./cli.js";
+
 vi.mock("execa", () => {
-  const execaMock = vi.fn();
-  execaMock.sync = vi.fn();
+  const sync = vi.fn();
+  const execaMock = Object.assign(vi.fn(), { sync });
   return { default: execaMock };
 });
 
-const { default: execa } = await import("execa");
-const { pnpm } = await import("./pnpm.js");
-const { Cli } = await import("./cli.js");
+type ExecaMock = {
+  sync: { mockImplementation(fn: (...args: unknown[]) => unknown): void };
+  mockReturnValue(v: unknown): void;
+};
+
+const execaMock = execa as unknown as ExecaMock;
 
-execa.sync.mockImplementation((...args) => {
+execaMock.sync.mockImplementation((...args) => {
   return {
-    stdout: `CMD: ${[].concat(...args.filter((arg) => typeof arg === "string" || Array.isArray(arg))).join(" ")}`
+    stdout: `CMD: ${([] as unknown[]).concat(...(args as (string | string[])[]).filter((arg) => typeof arg === "string" || Array.isArray(arg))).join(" ")}`
   };
 });
-execa.mockReturnValue({});
+execaMock.mockReturnValue({});
 
 describe("PnpmCli", () => {
   beforeEach(() => {
-    vi.spyOn(Cli, "getRaw").mockImplementation((...args) => {
-      return `CMD: ${[].concat(...args.filter((arg) => typeof arg === "string" || Array.isArray(arg))).join(" ")}`;
+    vi.spyOn(Cli, "getRaw").mockImplementation((...args: unknown[]) => {
+      return `CMD: ${([] as unknown[]).concat(...(args as (string | string[])[]).filter((arg) => typeof arg === "string" || Array.isArray(arg))).join(" ")}`;
     });
   });
   describe("newVersion", () => {

package/src/common/cli/{pnpm.js → pnpm.ts}

@@ -5,20 +5,20 @@ class PnpmCli extends Cli {
     super("pnpm");
   }
 
-  newVersion(version) {
+  newVersion(version: string) {
     // pnpm follows npm's version CLI semantics
     return this.version("--no-git-tag-version", version);
   }
 
-  version(...args) {
+  version(...args: string[]) {
     return this.sync("version", ...args);
   }
 
-  run(...args) {
+  run(...args: string[]) {
     return super.run("run", ...args);
   }
 
-  install(...args) {
+  install(...args: string[]) {
     return super.run("install", ...args);
   }
 

package/src/common/cli/{yarn.test.js → yarn.test.ts}

@@ -1,26 +1,31 @@
-vi.mock("execa", () => {
-  const execaMock = vi.fn();
-  execaMock.sync = vi.fn();
+import execa from "execa";
+import { yarn } from "./yarn.js";
+import { Cli } from "./cli.js";
 
+vi.mock("execa", () => {
+  const sync = vi.fn();
+  const execaMock = Object.assign(vi.fn(), { sync });
   return { default: execaMock };
 });
 
-const { default: execa } = await import("execa");
-const { yarn } = await import("./yarn.js");
-const { Cli } = await import("./cli.js");
+type ExecaMock = {
+  sync: { mockImplementation(fn: (...args: unknown[]) => unknown): void };
+  mockReturnValue(v: unknown): void;
+};
 
-execa.sync.mockImplementation((...args) => {
+const execaMock = execa as unknown as ExecaMock;
+
+execaMock.sync.mockImplementation((...args) => {
   return {
-    stdout: `CMD: ${[].concat(...args.filter((arg) => typeof arg === "string" || Array.isArray(arg))).join(" ")}`
+    stdout: `CMD: ${([] as unknown[]).concat(...(args as (string | string[])[]).filter((arg) => typeof arg === "string" || Array.isArray(arg))).join(" ")}`
   };
 });
-
-execa.mockReturnValue({});
+execaMock.mockReturnValue({});
 
 describe("YarnCli", () => {
   beforeEach(() => {
-    vi.spyOn(Cli, "getRaw").mockImplementation((...args) => {
-      return `CMD: ${[].concat(...args.filter((arg) => typeof arg === "string" || Array.isArray(arg))).join(" ")}`;
+    vi.spyOn(Cli, "getRaw").mockImplementation((...args: unknown[]) => {
+      return `CMD: ${([] as unknown[]).concat(...(args as (string | string[])[]).filter((arg) => typeof arg === "string" || Array.isArray(arg))).join(" ")}`;
     });
   });
   describe("newVersion", () => {

package/src/common/cli/{yarn.js → yarn.ts}

@@ -5,19 +5,19 @@ class YarnCli extends Cli {
     super("yarn");
   }
 
-  newVersion(version) {
+  newVersion(version: string) {
     return this.version("--no-git-tag-version", "--new-version", version);
   }
 
-  version(...args) {
+  version(...args: string[]) {
     return this.sync("version", ...args);
   }
 
-  run(...args) {
+  run(...args: string[]) {
     return super.run(...args);
   }
 
-  install(...args) {
+  install(...args: string[]) {
     return super.run("install", ...args);
   }
 

package/src/common/configure-git-workspace.ts

@@ -0,0 +1,39 @@
+import { git } from "./cli/git.js";
+
+interface GitWorkspaceContext {
+  logger: { info: (...args: unknown[]) => void };
+  config: {
+    SCM_TOKEN?: string;
+    REPOSITORY_URL?: string;
+    ORIGIN?: string;
+    GIT_USER_NAME?: string;
+    GIT_USER_EMAIL?: string;
+    GIT_DISABLE_SSL?: string | boolean;
+    [key: string]: unknown;
+  };
+}
+
+export function configureGitWorkspace(context: GitWorkspaceContext) {
+  const {
+    logger,
+    config: { SCM_TOKEN, REPOSITORY_URL, ORIGIN, GIT_USER_NAME, GIT_USER_EMAIL, GIT_DISABLE_SSL }
+  } = context;
+
+  if (GIT_USER_NAME && GIT_USER_EMAIL) {
+    git.config("--global", "user.name", `"${GIT_USER_NAME}"`);
+    git.config("--global", "user.email", `"${GIT_USER_EMAIL}"`);
+  }
+
+  if (GIT_DISABLE_SSL) {
+    logger.info("Disable SSL verification");
+    git.config("--global", "http.sslVerify", "false");
+  }
+
+  if (SCM_TOKEN) {
+    const repository = (REPOSITORY_URL ?? "").replace("https://", "");
+
+    logger.info(`Configure remote repository ${repository}`);
+    git.remote("remove", ORIGIN ?? "origin").sync();
+    git.remote("add", ORIGIN ?? "origin", `https://${SCM_TOKEN}@${repository}`).sync();
+  }
+}

package/src/common/{get-config.js → get-config.ts}

@@ -50,7 +50,7 @@ export function getCI() {
         CI_ORIGIN: "origin-git",
         REF_COMMIT: GITHUB_SHA,
         IS_PULL_REQUEST: false,
-        BRANCH_NAME: GITHUB_REF.replace("refs/heads/", "")
+        BRANCH_NAME: (GITHUB_REF as string).replace("refs/heads/", "")
       };
     }
 
@@ -75,6 +75,7 @@ export function getConfig() {
   const pkg = getPackageJson();
   const [owner, projectName] = pkg.name.replace(/^@/, "").split("/");
   const {
+    E2E_CMD,
     PROJECT_NAME,
     DOCKER_HUB_ID,
     DOCKER_HUB_PWD,
@@ -109,6 +110,7 @@ export function getConfig() {
 
   return {
     pkg,
+    E2E_CMD,
     PACKAGE_MANAGER: HAS_PNPM ? "pnpm" : HAS_BUN ? "bun" : HAS_YARN ? "yarn" : "npm",
     PROJECT_NAME: PROJECT_NAME || projectName,
     HAS_YARN,

package/src/common/{get-package-json.js → get-package-json.ts}

@@ -1,3 +1,4 @@
+// @ts-nocheck
 import fs from "fs";
 
 export function getPackageJson() {

package/src/common/{get-package-manager.js → get-package-manager.ts}

@@ -1,3 +1,4 @@
+// @ts-nocheck
 import { bun } from "./cli/bun.js";
 import { npm } from "./cli/npm.js";
 import { pnpm } from "./cli/pnpm.js";

package/src/common/{get-release-config.js → get-release-config.ts}

@@ -1,3 +1,4 @@
+// @ts-nocheck
 export async function getReleaseConfig() {
   try {
     return await import(`${process.cwd()}/release.config.mjs`);

package/src/common/{index.js → index.ts}

@@ -1,3 +1,4 @@
+// @ts-nocheck
 export * from "./cli/bun.js";
 export * from "./cli/cli.js";
 export * from "./cli/docker.js";

package/src/common/{run-command.test.js → run-command.test.ts}

@@ -1,3 +1,4 @@
+// @ts-nocheck
 vi.mock("listr", () => {
   return { default: vi.fn() };
 });

package/src/common/run-command.ts

@@ -0,0 +1,67 @@
+import chalk from "chalk";
+import figures from "figures";
+import inquirer from "inquirer";
+import { Listr, type ListrTask } from "listr2";
+
+import type { CmContext, CommandConstructor } from "./types.js";
+import { getConfig } from "./get-config.js";
+import { getReleaseConfig } from "./get-release-config.js";
+
+function createTasksRunner(tasks: ListrTask[], ctx: CmContext): Promise<void> {
+  return new Listr(tasks, {
+    concurrent: false,
+    renderer: !ctx.verbose ? "default" : "verbose"
+  }).run(ctx);
+}
+
+export async function runCommand(
+  klass: CommandConstructor,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  opts: Record<string, any>
+): Promise<void> {
+  try {
+    const config = getConfig();
+
+    let context = {
+      ...getReleaseConfig(),
+      ...config,
+      branch: { name: config.BRANCH_NAME as string },
+      config,
+      logger: console,
+      verbose: opts.verbose as number | undefined
+    } as unknown as CmContext;
+
+    const command = new klass();
+
+    if (command.mapContext) {
+      context = command.mapContext(opts as Record<string, unknown>, context);
+    }
+
+    if (command.prompt) {
+      context = {
+        ...context,
+        ...((await (inquirer as unknown as { prompt: (q: unknown) => Promise<Record<string, unknown>> }).prompt(
+          command.prompt(context)
+        )) as Record<string, unknown>)
+      };
+    }
+
+    command.verifyConditions?.(context);
+
+    const tasks = command.getTasks(context);
+
+    await createTasksRunner(tasks, context);
+
+    command.success?.(context);
+  } catch (er) {
+    console.error(chalk.red(figures.cross + " " + String(er)));
+    if (opts.verbose) {
+      console.error(String((er as Error).stack ?? "").replace(String(er), ""));
+    }
+    process.exit(-1);
+  }
+}
+
+process.on("unhandledRejection", () => {
+  // avoid extra promise rejection when using toObservable
+});

package/src/common/types.ts

@@ -0,0 +1,26 @@
+import type { ListrTask } from "listr2";
+import type { BaseContext, LastRelease, NextRelease } from "semantic-release";
+import type { getConfig } from "./get-config";
+
+export type CmContext<Extended = any> = BaseContext & {
+  config: ReturnType<typeof getConfig>;
+  branch: { name: string; type?: string };
+  nextRelease?: Partial<NextRelease>;
+  lastRelease?: Partial<LastRelease>;
+  verbose?: number;
+  output?: string[];
+} & Extended;
+
+export type SemanticContext = CmContext;
+
+export interface ICommand {
+  mapContext?(opts: Record<string, unknown>, context: CmContext): CmContext;
+  prompt?(context: CmContext): Array<Record<string, unknown>>;
+  verifyConditions?(context: CmContext): void;
+  getTasks(context: CmContext): ListrTask[];
+  success?(context: CmContext): void;
+}
+
+export type CommandConstructor = new () => ICommand;
+
+export type { ListrTask };

package/src/common/vendor.d.ts

@@ -0,0 +1,4 @@
+// Minimal @semantic-release/commit-analyzer type declarations
+declare module "@semantic-release/commit-analyzer" {
+  export function analyzeCommits(pluginConfig: unknown, context: unknown): Promise<string | null>;
+}

package/src/{index.js → index.ts}

@@ -1,4 +1,8 @@
-import * as commands from "./commands/index.js";
+import * as commands from "./commands";
+
+declare global {
+  const __VERSION__: string;
+}
 
 export * from "./commands/release.js";
 export * from "./common/index.js";