@cmflow/cli 3.4.0-alpha.1 → 3.4.0-alpha.5

package/src/common/cli/docker.ts

@@ -1,66 +0,0 @@
-import axios from "axios";
-
-import { Cli } from "./cli.js";
-
-class DockerCli extends Cli {
-  constructor() {
-    super("docker");
-  }
-
-  tag(...args: string[]) {
-    return this.get("tag", ...args);
-  }
-
-  login(...args: string[]) {
-    return this.sync("login", ...args);
-  }
-
-  push(...args: string[]) {
-    return this.run("push", ...args);
-  }
-
-  async getToken(username: string, password: string) {
-    const {
-      data: { token }
-    } = await axios({
-      method: "POST",
-      url: "https://hub.docker.com/v2/users/login/",
-      headers: {
-        Accept: "application/json",
-        "Content-Type": "application/json"
-      },
-      data: {
-        username,
-        password
-      }
-    });
-
-    return token;
-  }
-
-  async getTags({ token, repository }: { token: string; repository: string }) {
-    const { data } = await axios({
-      method: "GET",
-      url: `https://hub.docker.com/v2/repositories/${repository}/tags/?page=1&page_size=500`,
-      headers: {
-        Accept: "application/json",
-        Authorization: `JWT ${token}`
-      }
-    });
-
-    return data.results;
-  }
-
-  async deleteTag(tag: string, { token, repository }: { token: string; repository: string }) {
-    await axios({
-      method: "DELETE",
-      url: `https://hub.docker.com/v2/repositories/${repository}/tags/${tag}/`,
-      headers: {
-        Accept: "application/json",
-        Authorization: `JWT ${token}`
-      }
-    });
-  }
-}
-
-export const docker = new DockerCli();

package/src/common/cli/git.test.ts

@@ -1,215 +0,0 @@
-import execa from "execa";
-import { Cli } from "./cli.js";
-import { git } from "./git.js";
-
-vi.mock("execa", () => {
-  const sync = vi.fn();
-  const execaMock = Object.assign(vi.fn(), { sync });
-  return { default: execaMock };
-});
-
-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: ${([] as unknown[]).concat(...(args as (string | string[])[]).filter((arg) => typeof arg === "string" || Array.isArray(arg))).join(" ")}`
-  };
-});
-execaMock.mockReturnValue({});
-
-describe("GitCli", () => {
-  beforeEach(() => {
-    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", () => {
-    it("should run init cmd", () => {
-      const result = git.init("init-arg").sync();
-
-      expect(result.stdout).toEqual("CMD: git init init-arg");
-      expect(execa.sync).toHaveBeenCalledWith("git", ["init", "init-arg"], {
-        cwd: process.cwd(),
-        stdio: "inherit"
-      });
-    });
-  });
-  describe("add", () => {
-    it("should run add cmd", () => {
-      const result = git.add("add-arg").sync();
-
-      expect(result.stdout).toEqual("CMD: git add add-arg");
-      expect(execa.sync).toHaveBeenCalledWith("git", ["add", "add-arg"], {
-        cwd: process.cwd(),
-        stdio: "inherit"
-      });
-    });
-  });
-  describe("branch", () => {
-    it("should run branch cmd", () => {
-      const result = git.branch("branch-arg").sync();
-
-      expect(result.stdout).toEqual("CMD: git branch branch-arg");
-      expect(execa.sync).toHaveBeenCalledWith("git", ["branch", "branch-arg"], {
-        cwd: process.cwd(),
-        stdio: "inherit"
-      });
-    });
-  });
-  describe("clean", () => {
-    it("should run branch cmd", () => {
-      const result = git.clean("clean-arg").sync();
-
-      expect(result.stdout).toEqual("CMD: git clean clean-arg");
-      expect(execa.sync).toHaveBeenCalledWith("git", ["clean", "clean-arg"], {
-        cwd: process.cwd(),
-        stdio: "inherit"
-      });
-    });
-  });
-  describe("config", () => {
-    it("should run config cmd", () => {
-      const result = git.config("config-arg");
-
-      expect(result).toEqual("CMD: git config config-arg");
-      expect(Cli.getRaw).toHaveBeenCalledWith("git", ["config", "config-arg"], {
-        cwd: process.cwd()
-      });
-    });
-  });
-  describe("checkout", () => {
-    it("should run checkout cmd", () => {
-      const result = git.checkout("checkout-arg").sync();
-
-      expect(result.stdout).toEqual("CMD: git checkout checkout-arg");
-      expect(execa.sync).toHaveBeenCalledWith("git", ["checkout", "checkout-arg"], {
-        cwd: process.cwd(),
-        stdio: "inherit"
-      });
-    });
-  });
-  describe("commit", () => {
-    it("should run commit cmd", () => {
-      const result = git.commit("commit-arg").sync();
-
-      expect(result.stdout).toEqual("CMD: git commit commit-arg");
-      expect(execa.sync).toHaveBeenCalledWith("git", ["commit", "commit-arg"], {
-        cwd: process.cwd(),
-        stdio: "inherit"
-      });
-    });
-  });
-  describe("fetch", () => {
-    it("should run fetch cmd", () => {
-      const result = git.fetch("fetch-arg").sync();
-
-      expect(result.stdout).toEqual("CMD: git fetch fetch-arg");
-      expect(execa.sync).toHaveBeenCalledWith("git", ["fetch", "fetch-arg"], {
-        cwd: process.cwd(),
-        stdio: "inherit"
-      });
-    });
-  });
-  describe("prune", () => {
-    it("should run fetch cmd", () => {
-      const result = git.prune("prune-arg").sync();
-
-      expect(result.stdout).toEqual("CMD: git prune prune-arg");
-      expect(execa.sync).toHaveBeenCalledWith("git", ["prune", "prune-arg"], {
-        cwd: process.cwd(),
-        stdio: "inherit"
-      });
-    });
-  });
-  describe("merge", () => {
-    it("should run fetch cmd", () => {
-      const result = git.merge("merge-arg");
-
-      expect(result.stdout).toEqual("CMD: git merge merge-arg");
-      expect(execa.sync).toHaveBeenCalledWith("git", ["merge", "merge-arg"], {
-        cwd: process.cwd(),
-        stdio: "inherit"
-      });
-    });
-  });
-  describe("reset", () => {
-    it("should run reset cmd", () => {
-      const result = git.reset("reset-arg");
-
-      expect(result.stdout).toEqual("CMD: git reset reset-arg");
-      expect(execa.sync).toHaveBeenCalledWith("git", ["reset", "reset-arg"], {
-        cwd: process.cwd(),
-        stdio: "inherit"
-      });
-    });
-  });
-  describe("remote", () => {
-    it("should run remote cmd", () => {
-      const result = git.remote("remote-arg").sync();
-
-      expect(result.stdout).toEqual("CMD: git remote remote-arg");
-      expect(execa.sync).toHaveBeenCalledWith("git", ["remote", "remote-arg"], {
-        cwd: process.cwd(),
-        stdio: "inherit"
-      });
-    });
-  });
-  describe("rebase", () => {
-    it("should run rebase cmd", () => {
-      const result = git.rebase("rebase-arg").sync();
-
-      expect(result.stdout).toEqual("CMD: git rebase rebase-arg");
-      expect(execa.sync).toHaveBeenCalledWith("git", ["rebase", "rebase-arg"], {
-        cwd: process.cwd(),
-        stdio: "inherit"
-      });
-    });
-  });
-  describe("status", () => {
-    it("should run status cmd", () => {
-      const result = git.status("status-arg");
-
-      expect(result.stdout).toEqual("CMD: git status status-arg");
-      expect(execa.sync).toHaveBeenCalledWith("git", ["status", "status-arg"], {
-        cwd: process.cwd(),
-        stdio: "inherit"
-      });
-    });
-  });
-  describe("getCommitTag", () => {
-    it("should run revParse cmd", () => {
-      const result = git.getCommitTag("ref");
-
-      expect(result).toEqual("CMD: git rev-parse --short ref");
-    });
-  });
-  describe("getBranchName", () => {
-    it("should run revParse cmd", () => {
-      const result = git.getBranchName("ref");
-
-      expect(result).toEqual("CMD: git rev-parse --abbrev-ref ref");
-    });
-  });
-  describe("getLastCommitMsg", () => {
-    it("should run revParse cmd", () => {
-      const result = git.getLastCommitMsg();
-
-      expect(result).toEqual("CMD: git log -1 --pretty=%B");
-    });
-  });
-  describe("push", () => {
-    it("should run push cmd", async () => {
-      await git.push("push-arg");
-
-      expect(execa).toHaveBeenCalledWith("git", ["push", "push-arg"], {
-        cwd: process.cwd(),
-        stdio: "inherit"
-      });
-    });
-  });
-});

package/src/common/cli/git.ts

@@ -1,121 +0,0 @@
-import { Cli } from "./cli.js";
-
-class GitCli extends Cli {
-  constructor() {
-    super("git");
-  }
-
-  init(...args: string[]) {
-    return this.run("init", ...args);
-  }
-
-  add(...args: string[]) {
-    return this.run("add", ...args);
-  }
-
-  status(...args: string[]) {
-    return this.sync("status", ...args);
-  }
-
-  branch(...args: string[]) {
-    return this.run("branch", ...args);
-  }
-
-  clean(...args: string[]) {
-    return this.run("clean", ...args);
-  }
-
-  config(...args: string[]) {
-    return this.run("config", ...args).get();
-  }
-
-  checkout(...args: string[]) {
-    return this.run("checkout", ...args);
-  }
-
-  commit(...args: string[]) {
-    return this.run("commit", ...args);
-  }
-
-  fetch(...args: string[]) {
-    return this.run("fetch", ...args);
-  }
-
-  prune(...args: string[]) {
-    return this.run("prune", ...args);
-  }
-
-  merge(...args: string[]) {
-    return this.sync("merge", ...args);
-  }
-
-  reset(...args: string[]) {
-    return this.sync("reset", ...args);
-  }
-
-  remote(...args: string[]) {
-    return this.run("remote", ...args);
-  }
-
-  rebase(...args: string[]) {
-    return this.run("rebase", ...args);
-  }
-
-  getCommitTag(ref = "HEAD") {
-    return this.get("rev-parse", "--short", ref);
-  }
-
-  getBranchName(ref = "HEAD") {
-    return this.get("rev-parse", "--abbrev-ref", ref);
-  }
-
-  getLastCommitMsg() {
-    return this.get("log", "-1", "--pretty=%B");
-  }
-
-  push(...args: string[]) {
-    return this.run("push", ...args);
-  }
-
-  branchExists(branch: string, origin = "origin") {
-    return this.run("branch", "-a").getRaw().trim().includes(`remotes/${origin}/${branch}`);
-  }
-
-  checkBranchRemoteStatus(branch: string, origin = "origin") {
-    return this.run("cherry", branch, `${origin}/${branch}`).get();
-  }
-
-  branches(...args: string[]) {
-    return this.run("branch", ...args)
-      .get()
-      .split("\n")
-      .map((branch) => branch.trim().replace("* ", ""))
-      .filter((branch) => !!branch)
-      .filter((branch) => !String(branch).includes("/HEAD"));
-  }
-
-  show(branch: string) {
-    return this.run("show", '--format="%ci|%cr|%an"', branch, "--").getRaw().split("\n")[0].trim();
-  }
-
-  branchesInfos(...args: string[]) {
-    return this.branches(...args)
-      .map((branch) => {
-        try {
-          const [date, creation, author] = this.show(branch).split("|");
-          return {
-            branch,
-            date,
-            creation,
-            author
-          };
-        } catch {
-          return undefined;
-        }
-      })
-      .filter((b): b is { branch: string; date: string; creation: string; author: string } => !!b)
-      .sort((info1, info2) => (info1.date < info2.date ? 1 : -1));
-  }
-}
-
-export const git = new GitCli();

package/src/common/cli/lerna.test.ts

@@ -1,58 +0,0 @@
-import execa from "execa";
-import { lerna } from "./lerna.js";
-import { Cli } from "./cli.js";
-
-vi.mock("execa", () => {
-  const sync = vi.fn();
-  const execaMock = Object.assign(vi.fn(), { sync });
-  return { default: execaMock };
-});
-
-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: ${([] as unknown[]).concat(...(args as (string | string[])[]).filter((arg) => typeof arg === "string" || Array.isArray(arg))).join(" ")}`
-  };
-});
-execaMock.mockReturnValue({});
-
-describe("LernaCli", () => {
-  beforeEach(() => {
-    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", () => {
-    it("should run add cmd", () => {
-      const result = lerna.newVersion("1.0.0");
-
-      expect(result.stdout).toEqual("CMD: lerna version 1.0.0 --exact --yes --no-git-tag-version --no-push");
-    });
-  });
-  describe("run", () => {
-    it('should run "run" cmd', async () => {
-      await lerna.run("run-arg");
-
-      expect(execa).toHaveBeenCalledWith("lerna", ["run", "run-arg"], {
-        cwd: process.cwd(),
-        stdio: "inherit"
-      });
-    });
-  });
-  describe("install", () => {
-    it('should run "install" cmd', async () => {
-      await lerna.install("install-arg");
-
-      expect(execa).toHaveBeenCalledWith("lerna", ["install", "install-arg"], {
-        cwd: process.cwd(),
-        stdio: "inherit"
-      });
-    });
-  });
-});

package/src/common/cli/lerna.ts

@@ -1,25 +0,0 @@
-import { Cli } from "./cli.js";
-
-class LernaCli extends Cli {
-  constructor() {
-    super("lerna");
-  }
-
-  newVersion(version: string) {
-    return this.version(version, "--exact", "--yes", "--no-git-tag-version", "--no-push");
-  }
-
-  version(...args: string[]) {
-    return this.sync("version", ...args);
-  }
-
-  run(...args: string[]) {
-    return super.run("run", ...args);
-  }
-
-  install(...args: string[]) {
-    return super.run("install", ...args);
-  }
-}
-
-export const lerna = new LernaCli();

package/src/common/cli/npm.test.ts

@@ -1,58 +0,0 @@
-import execa from "execa";
-import { npm } from "./npm.js";
-import { Cli } from "./cli.js";
-
-vi.mock("execa", () => {
-  const sync = vi.fn();
-  const execaMock = Object.assign(vi.fn(), { sync });
-  return { default: execaMock };
-});
-
-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: ${([] as unknown[]).concat(...(args as (string | string[])[]).filter((arg) => typeof arg === "string" || Array.isArray(arg))).join(" ")}`
-  };
-});
-execaMock.mockReturnValue({});
-
-describe("NpmCli", () => {
-  beforeEach(() => {
-    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", () => {
-    it("should run newVersion cmd", () => {
-      const result = npm.newVersion("1.0.0");
-
-      expect(result.stdout).toEqual("CMD: npm version --no-git-tag-version 1.0.0");
-    });
-  });
-  describe("run", () => {
-    it('should run "run" cmd', async () => {
-      await npm.run("run-arg");
-
-      expect(execa).toHaveBeenCalledWith("npm", ["run", "run-arg"], {
-        cwd: process.cwd(),
-        stdio: "inherit"
-      });
-    });
-  });
-  describe("install", () => {
-    it('should run "install" cmd', async () => {
-      await npm.install("install-arg");
-
-      expect(execa).toHaveBeenCalledWith("npm", ["install", "install-arg"], {
-        cwd: process.cwd(),
-        stdio: "inherit"
-      });
-    });
-  });
-});

package/src/common/cli/npm.ts

@@ -1,33 +0,0 @@
-import { Cli } from "./cli.js";
-
-class NpmCli extends Cli {
-  constructor() {
-    super("npm");
-  }
-
-  newVersion(version: string) {
-    return this.version("--no-git-tag-version", version);
-  }
-
-  version(...args: string[]) {
-    return this.sync("version", ...args);
-  }
-
-  run(...args: string[]) {
-    return super.run("run", ...args);
-  }
-
-  install(...args: string[]) {
-    return super.run("install", ...args);
-  }
-
-  /**
-   * Reinstall dependencies without package-lock mutation
-   * @returns {Promise<unknown>}
-   */
-  restore() {
-    return super.run("ci");
-  }
-}
-
-export const npm = new NpmCli();

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

@@ -1,58 +0,0 @@
-import execa from "execa";
-import { pnpm } from "./pnpm.js";
-import { Cli } from "./cli.js";
-
-vi.mock("execa", () => {
-  const sync = vi.fn();
-  const execaMock = Object.assign(vi.fn(), { sync });
-  return { default: execaMock };
-});
-
-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: ${([] as unknown[]).concat(...(args as (string | string[])[]).filter((arg) => typeof arg === "string" || Array.isArray(arg))).join(" ")}`
-  };
-});
-execaMock.mockReturnValue({});
-
-describe("PnpmCli", () => {
-  beforeEach(() => {
-    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", () => {
-    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/cli/pnpm.ts

@@ -1,34 +0,0 @@
-import { Cli } from "./cli.js";
-
-class PnpmCli extends Cli {
-  constructor() {
-    super("pnpm");
-  }
-
-  newVersion(version: string) {
-    // pnpm follows npm's version CLI semantics
-    return this.version("--no-git-tag-version", version);
-  }
-
-  version(...args: string[]) {
-    return this.sync("version", ...args);
-  }
-
-  run(...args: string[]) {
-    return super.run("run", ...args);
-  }
-
-  install(...args: string[]) {
-    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();