@cmflow/cli 3.3.0 → 3.4.0-alpha.1

package/src/commands/tasks/{refresh-repository.js → refresh-repository.ts}

@@ -1,9 +1,9 @@
-import Listr from "listr";
-import { catchError, EMPTY } from "rxjs";
+import { Listr } from "listr2";
+import { catchError, EMPTY, type Observable } from "rxjs";
 
 import { git } from "../../common/index.js";
 
-function pipe(observable, output) {
+function pipe(observable: Observable<string>, output: unknown[]) {
   observable.pipe(
     catchError((err) => {
       output.push(err);
@@ -18,7 +18,11 @@ function pipe(observable, output) {
   return observable;
 }
 
-export function refreshRepository(context) {
+interface RefreshRepositoryContext {
+  output?: unknown[];
+}
+
+export function refreshRepository(context: RefreshRepositoryContext) {
   const { output = [] } = context;
 
   return {

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

@@ -0,0 +1,28 @@
+import { getPackageManager, git } from "../../common/index.js";
+import type { CmContext, ListrTask } from "../../common/types";
+
+type RunTestContext = CmContext<{
+  skipTest?: boolean;
+  skipUnit?: boolean;
+  skipE2E?: boolean;
+}>;
+
+export const runTest = ({ config: { E2E_CMD, PACKAGE_MANAGER }, skipTest, skipUnit, skipE2E }: RunTestContext): ListrTask[] => {
+  return [
+    {
+      title: "Unit test",
+      skip: () => Boolean(skipTest || skipUnit),
+      task: () => getPackageManager(PACKAGE_MANAGER).run("test")
+    },
+    {
+      title: "E2E test",
+      skip: () => Boolean(skipTest || skipE2E),
+      task: () => getPackageManager(PACKAGE_MANAGER).run(E2E_CMD || "test_e2e")
+    },
+    {
+      title: "Reset changes",
+      skip: () => !!skipTest,
+      task: () => git.reset("--hard") as unknown as void // reset files updated unit test
+    }
+  ];
+};

package/src/commands/tasks/{update-branch.js → update-branch.ts}

@@ -1,9 +1,19 @@
 import chalk from "chalk";
-import Listr from "listr";
+import { Listr } from "listr2";
 
 import { git } from "../../common/cli/git.js";
+import type { CmContext, ListrTask } from "../../common/types";
 
-async function checkBranchRemoteStatus({ featureBranch, origin, force }) {
+type UpdateBranchContext = CmContext<{
+  origin: string;
+  featureBranch: string;
+  fromBranch: string;
+  force: boolean;
+  checkStatus?: boolean;
+  rebase?: boolean;
+}>;
+
+async function checkBranchRemoteStatus({ featureBranch, origin, force }: UpdateBranchContext) {
   const isBranchExists = git.branchExists(featureBranch, origin);
 
   if (isBranchExists && !force) {
@@ -15,7 +25,8 @@ async function checkBranchRemoteStatus({ featureBranch, origin, force }) {
   }
 }
 
-export const updateBranch = ({ origin, featureBranch, fromBranch, force, checkStatus = true, rebase = true }) => {
+export const updateBranch = (context: UpdateBranchContext): ListrTask => {
+  const { origin, fromBranch, checkStatus = true, rebase = true } = context;
   return {
     title: "Rebase branch",
     task: () =>
@@ -24,12 +35,7 @@ export const updateBranch = ({ origin, featureBranch, fromBranch, force, checkSt
           {
             title: "Check status",
             enabled: () => checkStatus,
-            task: () =>
-              checkBranchRemoteStatus({
-                force,
-                featureBranch,
-                origin
-              })
+            task: () => checkBranchRemoteStatus(context)
           },
           {
             title: `Rebase from ${origin}/${chalk.green(fromBranch)}`,

package/src/commands/tasks/{update-dependencies.js → update-dependencies.ts}

@@ -1,10 +1,11 @@
-import Listr from "listr";
+import { Listr } from "listr2";
 import { catchError } from "rxjs";
 
 import { getPackageManager } from "../../common/index.js";
+import type { CmContext, ListrTask } from "../../common/types";
 import { refreshMetadata, shouldReinstall } from "../utils/check-install.js";
 
-export const updateDependencies = ({ PACKAGE_MANAGER }) => {
+export const updateDependencies = ({ config: { PACKAGE_MANAGER } }: CmContext): ListrTask => {
   const reinstall = shouldReinstall();
 
   return {
@@ -36,7 +37,7 @@ export const updateDependencies = ({ PACKAGE_MANAGER }) => {
             task: () => refreshMetadata()
           }
         ],
-        { concurrency: false }
+        { concurrent: false }
       )
   };
 };

package/src/common/back/directus/{directus-flow.test.js → directus-flow.test.ts}

@@ -1,3 +1,4 @@
+// @ts-nocheck
 // Use vi.hoisted to create mock references that are available to mock factories
 const httpRequestMock = vi.hoisted(() => vi.fn());
 

package/src/common/back/directus/{directus-flow.js → directus-flow.ts}

@@ -11,12 +11,20 @@ import { httpRequest } from "../http/http-request.js";
  * @param {object} [opts] - Additional request options (e.g., rejectUnauthorized)
  * @returns {Promise<unknown>} The parsed JSON response
  */
-export async function triggerDirectusFlow(projectId, versions, opts = {}) {
+export async function triggerDirectusFlow(projectId: string, versions: string[], opts: Record<string, unknown> = {}) {
   const { DIRECTUS_URL, DIRECTUS_FLOW_ID, DIRECTUS_ACCESS_TOKEN } = getConfig();
 
   const endpoint = `${DIRECTUS_URL}/flows/trigger/${DIRECTUS_FLOW_ID}`;
 
-  const options = {
+  const options: {
+    method: string;
+    callee: string;
+    headers: Record<string, string>;
+    data: Record<string, unknown> | string;
+    retries: number;
+    retryDelay: unknown;
+    [key: string]: unknown;
+  } = {
     method: "post",
     callee: "DIRECTUS",
     headers: {

package/src/common/back/http/{http-proxy.js → http-proxy.ts}

@@ -4,7 +4,13 @@ import { getConfig } from "../../get-config.js";
 
 const { HTTPS_PROXY } = getConfig();
 
-export const getHttpProxy = (opts) => {
+interface HttpProxyOptions {
+  callee?: string;
+  rejectUnauthorized?: boolean;
+  [key: string]: unknown;
+}
+
+export const getHttpProxy = (opts: HttpProxyOptions) => {
   if (HTTPS_PROXY) {
     console.debug({
       message: `Using proxy agent for ${opts.callee} requests`,

package/src/common/back/http/{http-request.spec.js → http-request.spec.ts}

@@ -9,12 +9,12 @@ vi.mock("axios-retry");
 vi.mock("./http-proxy.js");
 
 describe("httpRequest", () => {
-  let mockInstance;
+  let mockInstance: ReturnType<typeof vi.fn>;
 
   beforeEach(() => {
     vi.clearAllMocks();
     mockInstance = vi.fn();
-    vi.mocked(axios.create).mockReturnValue(mockInstance);
+    vi.mocked(axios.create).mockReturnValue(mockInstance as unknown as ReturnType<typeof axios.create>);
   });
 
   it("should create an agent in production with proxy", async () => {
@@ -37,11 +37,12 @@ describe("httpRequest", () => {
   });
 
   it("should throw an error if the response is not ok", async () => {
-    const axiosError = new Error("Request failed");
-    axiosError.response = {
-      status: 500,
-      data: { error: "Internal server error" }
-    };
+    const axiosError = Object.assign(new Error("Request failed"), {
+      response: {
+        status: 500,
+        data: { error: "Internal server error" }
+      }
+    });
     mockInstance.mockRejectedValue(axiosError);
 
     await expect(httpRequest("http://example.com/test-endpoint", { callee: "test" })).rejects.toThrow("HTTP error! status: 500");

package/src/common/back/http/{http-request.js → http-request.ts}

@@ -11,23 +11,19 @@ import { getHttpProxy } from "./http-proxy.js";
  * @property {boolean} [retryOnIdempotentRequests=true] - Retry on 5xx for idempotent requests
  */
 
-/**
- * @typedef {Object} HttpRequestOptions
- * @property {boolean} [rejectUnauthorized] - Whether to reject unauthorized SSL certificates
- * @property {string} [callee] - The name of the caller
- * @property {Record<string, string>} [params] - Query parameters to be included in the request
- * @property {string} [method] - HTTP method (default: 'get')
- * @property {Record<string, string>} [headers] - Custom headers to be included in the request
- * @property {RetryOptions|boolean} [retry] - Retry configuration (true for defaults, or custom config)
- */
+interface HttpRequestOptions {
+  rejectUnauthorized?: boolean;
+  callee?: string;
+  params?: Record<string, string>;
+  method?: string;
+  headers?: Record<string, string>;
+  retries?: number;
+  retryDelay?: unknown;
+  data?: unknown;
+  [key: string]: unknown;
+}
 
-/**
- *
- * @param endpoint {string}
- * @param options {HttpRequestOptions}
- * @return {Promise<*>}
- */
-export async function httpRequest(endpoint, options = {}) {
+export async function httpRequest(endpoint: string, options: HttpRequestOptions = {}) {
   const { callee, headers, method = "get", params = {}, rejectUnauthorized, ...rest } = options;
   const httpsAgent = getHttpProxy({
     rejectUnauthorized,
@@ -36,7 +32,7 @@ export async function httpRequest(endpoint, options = {}) {
 
   const instance = axios.create();
 
-  axiosRetry(instance, options);
+  axiosRetry(instance, options as Parameters<typeof axiosRetry>[1]);
 
   try {
     const response = await instance({
@@ -60,8 +56,9 @@ export async function httpRequest(endpoint, options = {}) {
 
     return response.data;
   } catch (error) {
-    const status = error.response?.status;
-    const responseData = error.response?.data;
+    const axiosError = error as { response?: { status: number; data: unknown } };
+    const status = axiosError.response?.status;
+    const responseData = axiosError.response?.data;
 
     console.error({
       ...options,

package/src/common/back/jira/{get-sorted-releases.js → get-sorted-releases.ts}

@@ -8,7 +8,7 @@ import { getJiraReleases } from "./jira-releases.js";
  * @param component {string}
  * @param tagVersion {string}
  */
-export async function getSortedReleases(projectId, component, tagVersion) {
+export async function getSortedReleases(projectId: string, component: string, tagVersion: string) {
   const releases = await getJiraReleases(projectId);
 
   const promises = releases
@@ -24,7 +24,7 @@ export async function getSortedReleases(projectId, component, tagVersion) {
       }
     })
     .sort((ra, rb) => {
-      return semver.rcompare(ra.version, rb.version);
+      return semver.rcompare(ra.version!, rb.version!);
     });
 
   const [current, ...others] = await Promise.all(promises);

package/src/common/back/jira/{jira-releases.js → jira-releases.ts}

@@ -1,6 +1,17 @@
 import { jiraRequest } from "./jira-request.js";
 
-export async function getJiraReleases(projectId) {
+interface JiraRelease {
+  id: string;
+  name: string;
+  description?: string;
+  archived?: boolean;
+  released?: boolean;
+  projectId?: string;
+  releaseDate?: string;
+  version?: string;
+}
+
+export async function getJiraReleases(projectId: string): Promise<JiraRelease[]> {
   const endpoint = `/rest/api/3/project/${projectId}/versions?expand`;
   const response = await jiraRequest(endpoint);
 
@@ -8,10 +19,10 @@ export async function getJiraReleases(projectId) {
     return [];
   }
 
-  return response;
+  return response as JiraRelease[];
 }
 
-export async function updateJiraRelease(release) {
+export async function updateJiraRelease(release: JiraRelease) {
   const endpoint = `/rest/api/3/version/${release.id}`;
   try {
     await jiraRequest(endpoint, {

package/src/common/back/jira/{jira-request.js → jira-request.ts}

@@ -3,7 +3,15 @@ import axiosRetry from "axios-retry";
 import { getConfig } from "../../get-config.js";
 import { httpRequest } from "../http/http-request.js";
 
-export async function jiraRequest(endpoint, opts = {}) {
+interface JiraRequestOptions {
+  method?: string;
+  headers?: Record<string, string>;
+  data?: unknown;
+  params?: Record<string, string>;
+  [key: string]: unknown;
+}
+
+export async function jiraRequest(endpoint: string, opts: JiraRequestOptions = {}) {
   const { JIRA_API, JIRA_TOKEN, JIRA_EMAIL } = getConfig();
   const jiraUrl = `${JIRA_API}${endpoint}`;
   const auth = Buffer.from(`${JIRA_EMAIL}:${JIRA_TOKEN}`).toString("base64");

package/src/common/back/jira/{jira-search.js → jira-search.ts}

@@ -7,10 +7,10 @@ import { jiraRequest } from "./jira-request.js";
  * @param opts {object} Options
  * @returns {Promise<{issues: (import("./interfaces/JiraIIssue.d.ts").JiraIssue & Expand)[], total: number, maxResults: number}>}
  */
-export function jiraSearch(jql, opts) {
+export function jiraSearch(jql: string, opts?: Record<string, unknown>) {
   return jiraRequest("/rest/api/3/search/jql", {
     params: {
-      ...opts,
+      ...(opts as Record<string, string>),
       jql
     }
   });

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

@@ -1,24 +1,31 @@
+import execa from "execa";
+import { bun } from "./bun.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 { bun } = await import("./bun.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("BunCli", () => {
   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/{bun.js → bun.ts}

@@ -5,19 +5,19 @@ class BunCli extends Cli {
     super("bun");
   }
 
-  newVersion(version) {
+  newVersion(version: string) {
     return this.pm("version", "--no-git-tag-version", version);
   }
 
-  pm(...args) {
+  pm(...args: string[]) {
     return this.sync("pm", ...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/cli.ts

@@ -0,0 +1,127 @@
+import "any-observable/register/rxjs-all.js";
+
+import { spawnSync, type SpawnSyncOptions } from "child_process";
+import execa from "execa";
+import { filter, fromEvent, map, merge, takeUntil } from "rxjs";
+import type { Observable } from "rxjs";
+
+type RunOptions = Record<string, unknown>;
+
+export interface CliResult extends Promise<unknown> {
+  toObservable(opt?: RunOptions): Observable<string>;
+  toStream(opt?: RunOptions): execa.ExecaChildProcess<string>;
+  cwd(cwd: string): CliResult;
+  sync(opt?: RunOptions): execa.ExecaSyncReturnValue<string>;
+  getRaw(opt?: RunOptions): string;
+  get(opt?: RunOptions): string;
+}
+
+export class Cli {
+  cmd: string;
+
+  constructor(cmd: string) {
+    this.cmd = cmd;
+  }
+
+  sync(...args: string[]): execa.ExecaSyncReturnValue<string> {
+    return (Cli.run(this.cmd, args) as CliResult).sync();
+  }
+
+  run(...args: string[]): CliResult {
+    return Cli.run(this.cmd, args);
+  }
+
+  get(...args: string[]): string {
+    return (Cli.run(this.cmd, args) as CliResult).get();
+  }
+
+  static run(cmd: string, args: string[] = [], options: RunOptions = {}): CliResult {
+    const run = (opt: RunOptions = {}) => {
+      return execa(cmd, args, {
+        cwd: process.cwd(),
+        ...opt,
+        ...options
+      } as execa.Options);
+    };
+
+    let isPromise = true;
+
+    const promise = new Promise<void>((resolve, reject) => {
+      setTimeout(async () => {
+        if (isPromise) {
+          try {
+            const result = await run({
+              stdio: "inherit"
+            });
+
+            resolve(result as unknown as void);
+          } catch (err) {
+            reject(err);
+          }
+        } else {
+          resolve();
+        }
+      }, 10);
+    });
+
+    const cliResult = promise as unknown as CliResult;
+
+    cliResult.toObservable = (opt?: RunOptions): Observable<string> => {
+      isPromise = false;
+      const cp = run(opt);
+      const end$ = fromEvent(cp, "close");
+      const stdout$ = fromEvent(cp.stdout!, "data").pipe(
+        takeUntil(end$),
+        map((data) => (data as Buffer).toString())
+      );
+      const stderr$ = fromEvent(cp.stderr!, "data").pipe(
+        takeUntil(end$),
+        map((data) => (data as Buffer).toString())
+      );
+
+      return merge(stdout$, stderr$).pipe(filter(Boolean));
+    };
+
+    cliResult.toStream = (opt?: RunOptions) => {
+      isPromise = false;
+
+      return run(opt);
+    };
+
+    cliResult.cwd = (cwd: string) => {
+      options.cwd = cwd;
+      return cliResult;
+    };
+
+    cliResult.sync = (opt?: RunOptions) => {
+      isPromise = false;
+      return execa.sync(cmd, args, {
+        cwd: process.cwd(),
+        stdio: "inherit",
+        ...options,
+        ...opt
+      } as execa.SyncOptions);
+    };
+
+    cliResult.getRaw = (opt?: RunOptions): string => {
+      isPromise = false;
+      return Cli.getRaw(cmd, args, {
+        cwd: process.cwd(),
+        ...options,
+        ...opt
+      });
+    };
+
+    cliResult.get = cliResult.getRaw;
+
+    return cliResult;
+  }
+
+  static getRaw(cmd: string, args: string[], options?: RunOptions): string {
+    return (spawnSync(cmd, args, options as SpawnSyncOptions).output as (Buffer | null)[])
+      .filter((o): o is Buffer => o !== null)
+      .map((o) => o.toString())
+      .join("\n")
+      .trim();
+  }
+}

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

@@ -1,28 +1,36 @@
+import execa from "execa";
+import axios from "axios";
+import { docker } from "./docker.js";
+import { Cli } from "./cli.js";
+
 vi.mock("axios", () => {
   return { default: vi.fn() };
 });
 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 { default: axios } = await import("axios");
-const { docker } = await import("./docker.js");
-const { Cli } = await import("./cli.js");
 
-execa.mockReturnValue({});
+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.mockReturnValue({});
+
+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(" ")}`
   };
 });
 
 describe("DockerCli", () => {
   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("tag", () => {
@@ -58,7 +66,7 @@ describe("DockerCli", () => {
   });
   describe("getToken", () => {
     beforeEach(() => {
-      axios.mockReturnValue({ data: { token: "token" } });
+      vi.mocked(axios).mockReturnValue({ data: { token: "token" } } as unknown as ReturnType<typeof axios>);
     });
     it("should get token", async () => {
       const token = await docker.getToken("username", "password");
@@ -80,7 +88,7 @@ describe("DockerCli", () => {
   });
   describe("getTags", () => {
     beforeEach(() => {
-      axios.mockReturnValue({
+      vi.mocked(axios).mockReturnValue({
         data: {
           results: [
             {
@@ -89,7 +97,7 @@ describe("DockerCli", () => {
             }
           ]
         }
-      });
+      } as unknown as ReturnType<typeof axios>);
     });
     it("should get token", async () => {
       const tags = await docker.getTags({

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

@@ -7,19 +7,19 @@ class DockerCli extends Cli {
     super("docker");
   }
 
-  tag(...args) {
+  tag(...args: string[]) {
     return this.get("tag", ...args);
   }
 
-  login(...args) {
+  login(...args: string[]) {
     return this.sync("login", ...args);
   }
 
-  push(...args) {
+  push(...args: string[]) {
     return this.run("push", ...args);
   }
 
-  async getToken(username, password) {
+  async getToken(username: string, password: string) {
     const {
       data: { token }
     } = await axios({
@@ -38,7 +38,7 @@ class DockerCli extends Cli {
     return token;
   }
 
-  async getTags({ token, repository }) {
+  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`,
@@ -51,7 +51,7 @@ class DockerCli extends Cli {
     return data.results;
   }
 
-  async deleteTag(tag, { token, repository }) {
+  async deleteTag(tag: string, { token, repository }: { token: string; repository: string }) {
     await axios({
       method: "DELETE",
       url: `https://hub.docker.com/v2/repositories/${repository}/tags/${tag}/`,