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

package/src/commands/tasks/merge-branch.ts

@@ -1,80 +0,0 @@
-import { git } from "../../common/index.js";
-
-interface MergeBranchConfig {
-  SCM_TOKEN?: string;
-  REPOSITORY_URL: string;
-  ORIGIN: string;
-  PRODUCTION_BRANCH: string;
-}
-
-interface MergeBranchContext {
-  logger: { info: (msg: string, ...args: unknown[]) => void };
-  branch: { name: string };
-  config: MergeBranchConfig;
-  BRANCH_NAME: string;
-  PRODUCTION_BRANCH: string;
-}
-
-function setGHToken(context: MergeBranchContext) {
-  const {
-    logger,
-    config: { SCM_TOKEN, REPOSITORY_URL, ORIGIN }
-  } = context;
-
-  if (SCM_TOKEN) {
-    const repository = REPOSITORY_URL.replace("https://", "");
-
-    logger.info(`Configure remote repository ${repository}`);
-    git.remote("remove", ORIGIN).sync();
-    git.remote("add", ORIGIN, `https://${SCM_TOKEN}@${repository}`).sync();
-  }
-}
-
-async function gitMep(context: MergeBranchContext) {
-  const {
-    logger,
-    branch,
-    config: { PRODUCTION_BRANCH, ORIGIN }
-  } = context;
-
-  logger.info(`Branch ${branch.name} is candidate to MEP`);
-
-  git.reset("--hard");
-  git.clean("-f", "-d").sync();
-
-  logger.info("Checkout production branch");
-
-  git.config("--replace-all", "remote.origin.fetch", "+refs/heads/*:refs/remotes/origin/*");
-  git.fetch().sync();
-  git.fetch("--tags").sync();
-  git.checkout("-qf", PRODUCTION_BRANCH).sync();
-
-  logger.info(`Current branch: ${PRODUCTION_BRANCH}`);
-
-  const building = git.getLastCommitMsg();
-  logger.info("Last commit message on production", building);
-
-  logger.info(`Merge ${branch.name} into ${PRODUCTION_BRANCH} branch`);
-  git.merge("--no-ff", "-m", `${branch.name}`, branch.name);
-  logger.info(`${branch.name} merged into ${PRODUCTION_BRANCH} branch`);
-
-  setGHToken(context);
-
-  logger.info(`Push ${PRODUCTION_BRANCH} branch`);
-  await git.push(ORIGIN, PRODUCTION_BRANCH);
-  logger.info(`${PRODUCTION_BRANCH} branch pushed`);
-
-  logger.info(`Remove ${ORIGIN}/${branch.name} branch`);
-  await git.push(ORIGIN, ":" + branch.name);
-  logger.info(`${ORIGIN}/${branch.name} branch correctly removed`);
-}
-
-export function mergeBranch(context: MergeBranchContext) {
-  const { BRANCH_NAME, PRODUCTION_BRANCH } = context;
-  return {
-    title: `Merge ${BRANCH_NAME} into ${PRODUCTION_BRANCH}`,
-    task: async () => {
-      await gitMep(context);
-    }
-  };
-}

package/src/commands/tasks/push-branch.ts

@@ -1,19 +0,0 @@
-import { git } from "../../common/cli/git.js";
-
-interface PushBranchContext {
-  origin?: string;
-  featureBranch: string;
-  upstream?: boolean;
-  noVerify?: boolean;
-}
-
-export function pushBranch({ origin = "origin", featureBranch, upstream = true, noVerify = true }: PushBranchContext) {
-  return {
-    title: `Push ${featureBranch}`,
-    task: () => {
-      return git
-        .push(...([upstream ? "-u" : "", "-f", origin, featureBranch, noVerify ? "--no-verify" : ""].filter(Boolean) as string[]))
-        .toObservable();
-    }
-  };
-}

package/src/commands/tasks/rebase-all-branches.ts

@@ -1,37 +0,0 @@
-import { git } from "../../common/cli/git.js";
-
-interface RebaseAllBranchesContext {
-  origin?: string;
-  upstream?: boolean;
-  noVerify?: boolean;
-  PRODUCTION_BRANCH: string;
-  DEVELOP_BRANCH: string;
-}
-
-export function rebaseAllBranches(context: RebaseAllBranchesContext) {
-  const { origin = "origin", upstream = true, noVerify = true } = context;
-  return {
-    title: "Rebase all branches",
-    task: async () => {
-      const remoteBranches = git
-        .branches("-r")
-        .filter((b) => !new RegExp(`${context.PRODUCTION_BRANCH}|${context.DEVELOP_BRANCH}`).test(b));
-      for (const remoteBranch of remoteBranches) {
-        const branch = remoteBranch.split("/")[1];
-        try {
-          await git.branch("-D", branch);
-        } catch {}
-        try {
-          await git.checkout("--track", remoteBranch);
-          await git.rebase(`${origin}/${context.PRODUCTION_BRANCH}`);
-          await git.push(...([upstream ? "-u" : "", "-f", origin, branch, noVerify ? "--no-verify" : ""].filter(Boolean) as string[]));
-        } catch {
-          try {
-            await git.rebase("--abort");
-            await git.reset("--hard");
-          } catch {}
-        }
-      }
-    }
-  };
-}

package/src/commands/tasks/refresh-repository.ts

@@ -1,38 +0,0 @@
-import { Listr } from "listr2";
-import { catchError, EMPTY, type Observable } from "rxjs";
-
-import { git } from "../../common/index.js";
-
-function pipe(observable: Observable<string>, output: unknown[]) {
-  observable.pipe(
-    catchError((err) => {
-      output.push(err);
-      return EMPTY;
-    })
-  );
-
-  observable.subscribe((result) => {
-    output.push(result);
-  });
-
-  return observable;
-}
-
-interface RefreshRepositoryContext {
-  output?: unknown[];
-}
-
-export function refreshRepository(context: RefreshRepositoryContext) {
-  const { output = [] } = context;
-
-  return {
-    title: "Refresh local repository",
-    task: () =>
-      new Listr([
-        {
-          title: "Git fetch",
-          task: () => pipe(git.fetch("--prune").toObservable(), output)
-        }
-      ])
-  };
-}

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

@@ -1,28 +0,0 @@
-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.ts

@@ -1,49 +0,0 @@
-import chalk from "chalk";
-import { Listr } from "listr2";
-
-import { git } from "../../common/cli/git.js";
-import type { CmContext, ListrTask } from "../../common/types";
-
-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) {
-    const result = git.checkBranchRemoteStatus(featureBranch);
-
-    if (result) {
-      throw new Error("Remote branch changed, check diff before continue");
-    }
-  }
-}
-
-export const updateBranch = (context: UpdateBranchContext): ListrTask => {
-  const { origin, fromBranch, checkStatus = true, rebase = true } = context;
-  return {
-    title: "Rebase branch",
-    task: () =>
-      new Listr(
-        [
-          {
-            title: "Check status",
-            enabled: () => checkStatus,
-            task: () => checkBranchRemoteStatus(context)
-          },
-          {
-            title: `Rebase from ${origin}/${chalk.green(fromBranch)}`,
-            enabled: () => rebase,
-            task: () => git.rebase(`${origin}/${fromBranch}`).toObservable()
-          }
-        ],
-        { concurrent: false }
-      )
-  };
-};

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

@@ -1,43 +0,0 @@
-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 = ({ config: { PACKAGE_MANAGER } }: CmContext): ListrTask => {
-  const reinstall = shouldReinstall();
-
-  return {
-    title: "Install",
-    enabled: () => reinstall,
-    task: () =>
-      new Listr(
-        [
-          {
-            title: `Restore dependencies using ${PACKAGE_MANAGER.toUpperCase()}`,
-            task: () =>
-              getPackageManager(PACKAGE_MANAGER)
-                .restore()
-                .toObservable()
-                .pipe(
-                  catchError((error) => {
-                    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.");
-                      }
-                    }
-
-                    throw error;
-                  })
-                )
-          },
-          {
-            title: "Refresh metadata",
-            task: () => refreshMetadata()
-          }
-        ],
-        { concurrent: false }
-      )
-  };
-};

package/src/commands/utils/check-install.ts

@@ -1,31 +0,0 @@
-import isEqual from "lodash/isEqual.js";
-
-import { getPackageJson, git } from "../../common/index.js";
-
-function getDeps() {
-  const pkg = getPackageJson();
-  return {
-    dependencies: pkg.dependencies,
-    devDependencies: pkg.devDependencies
-  };
-}
-
-export function getHash() {
-  return Buffer.from(JSON.stringify(getDeps())).toString("base64");
-}
-
-export function getDepsFromHash() {
-  try {
-    return JSON.parse(Buffer.from(git.config("--local", "npm.hash"), "base64").toString("utf8"));
-  } catch {
-    return "";
-  }
-}
-
-export function shouldReinstall() {
-  return !isEqual(getDeps(), getDepsFromHash());
-}
-
-export function refreshMetadata() {
-  git.config("--local", "npm.hash", `${getHash()}`);
-}

package/src/common/back/directus/directus-flow.test.ts

@@ -1,63 +0,0 @@
-// @ts-nocheck
-// Use vi.hoisted to create mock references that are available to mock factories
-const httpRequestMock = vi.hoisted(() => vi.fn());
-
-// Mock get-config to provide DIRECTUS_* env values
-vi.mock("../../get-config.js", () => ({
-  getConfig: () => ({
-    DIRECTUS_URL: "https://directus.example.com",
-    DIRECTUS_FLOW_ID: "flow-123",
-    DIRECTUS_ACCESS_TOKEN: "token-abc"
-  })
-}));
-
-// Spy/mock for httpRequest
-vi.mock("../http/http-request.js", () => ({
-  httpRequest: httpRequestMock
-}));
-
-// Now import the SUT after mocks are in place
-import { triggerDirectusFlow } from "./directus-flow.js";
-
-describe("triggerDirectusFlow", () => {
-  beforeEach(() => {
-    httpRequestMock.mockReset();
-  });
-
-  it("should call httpRequest with the expected endpoint, headers and body", async () => {
-    httpRequestMock.mockResolvedValue({ ok: true, data: { status: "queued" } });
-
-    const projectId = "CMAB";
-    const versions = ["2.3.0", "2.2.0"];
-    const opts = { rejectUnauthorized: true };
-
-    const result = await triggerDirectusFlow(projectId, versions, opts);
-
-    expect(result).toEqual({ ok: true, data: { status: "queued" } });
-
-    expect(httpRequestMock).toHaveBeenCalledTimes(1);
-
-    const expectedEndpoint = "https://directus.example.com/flows/trigger/flow-123";
-    const expectedBody = JSON.stringify({ projectId, versions });
-
-    expect(httpRequestMock).toHaveBeenCalledWith(
-      expectedEndpoint,
-      expect.objectContaining({
-        method: "post",
-        callee: "DIRECTUS",
-        rejectUnauthorized: true,
-        headers: expect.objectContaining({
-          Authorization: "Bearer token-abc",
-          "Content-Type": "application/json"
-        }),
-        data: expectedBody
-      })
-    );
-  });
-
-  it("should propagate errors from httpRequest", async () => {
-    httpRequestMock.mockRejectedValue(new Error("network error"));
-
-    await expect(triggerDirectusFlow("CMAB", ["1.0.0"])).rejects.toThrow("network error");
-  });
-});

package/src/common/back/directus/directus-flow.ts

@@ -1,48 +0,0 @@
-import axiosRetry from "axios-retry";
-
-import { getConfig } from "../../get-config.js";
-import { httpRequest } from "../http/http-request.js";
-
-/**
- * Trigger a Directus Flow
- *
- * @param {string} projectId - The project identifier to send to the flow
- * @param {string[]} versions - The versions list to send to the flow
- * @param {object} [opts] - Additional request options (e.g., rejectUnauthorized)
- * @returns {Promise<unknown>} The parsed JSON response
- */
-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: {
-    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: {
-      Authorization: `Bearer ${DIRECTUS_ACCESS_TOKEN}`,
-      "Content-Type": "application/json"
-    },
-    data: {
-      projectId,
-      versions
-    },
-    retries: 3,
-    retryDelay: axiosRetry.exponentialDelay,
-    ...opts
-  };
-
-  if (options.data && options.headers?.["Content-Type"] === "application/json") {
-    options.data = JSON.stringify(options.data);
-  }
-
-  return httpRequest(endpoint, options);
-}

package/src/common/back/http/http-proxy.ts

@@ -1,21 +0,0 @@
-import { HttpsProxyAgent } from "https-proxy-agent";
-
-import { getConfig } from "../../get-config.js";
-
-const { HTTPS_PROXY } = getConfig();
-
-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`,
-      value: HTTPS_PROXY
-    });
-    return new HttpsProxyAgent(HTTPS_PROXY, opts);
-  }
-};

package/src/common/back/http/http-request.spec.ts

@@ -1,50 +0,0 @@
-import axios from "axios";
-import axiosRetry from "axios-retry";
-
-import { getHttpProxy } from "./http-proxy.js";
-import { httpRequest } from "./http-request.js";
-
-vi.mock("axios");
-vi.mock("axios-retry");
-vi.mock("./http-proxy.js");
-
-describe("httpRequest", () => {
-  let mockInstance: ReturnType<typeof vi.fn>;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockInstance = vi.fn();
-    vi.mocked(axios.create).mockReturnValue(mockInstance as unknown as ReturnType<typeof axios.create>);
-  });
-
-  it("should create an agent in production with proxy", async () => {
-    mockInstance.mockResolvedValue({
-      status: 200,
-      data: { data: "test" }
-    });
-
-    const result = await httpRequest("http://example.com/test-endpoint", {
-      callee: "test"
-    });
-
-    expect(getHttpProxy).toHaveBeenCalledWith({
-      rejectUnauthorized: undefined,
-      callee: "test"
-    });
-    expect(axios.create).toHaveBeenCalled();
-    expect(axiosRetry).toHaveBeenCalled();
-    expect(result).toEqual({ data: "test" });
-  });
-
-  it("should throw an error if the response is not ok", async () => {
-    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.ts

@@ -1,74 +0,0 @@
-import axios from "axios";
-import axiosRetry from "axios-retry";
-
-import { getHttpProxy } from "./http-proxy.js";
-
-/**
- * @typedef {Object} RetryOptions
- * @property {number} [retries=3] - Number of retry attempts
- * @property {number} [retryDelay=1000] - Delay between retries in ms
- * @property {boolean} [retryOnNetworkError=true] - Retry on network errors
- * @property {boolean} [retryOnIdempotentRequests=true] - Retry on 5xx for idempotent requests
- */
-
-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;
-}
-
-export async function httpRequest(endpoint: string, options: HttpRequestOptions = {}) {
-  const { callee, headers, method = "get", params = {}, rejectUnauthorized, ...rest } = options;
-  const httpsAgent = getHttpProxy({
-    rejectUnauthorized,
-    callee
-  });
-
-  const instance = axios.create();
-
-  axiosRetry(instance, options as Parameters<typeof axiosRetry>[1]);
-
-  try {
-    const response = await instance({
-      url: endpoint,
-      method,
-      params,
-      headers: {
-        ...headers,
-        "Content-Type": "application/json"
-      },
-      httpsAgent,
-      ...rest
-    });
-
-    console.info({
-      message: `Successfully retrieved data from ${callee}`,
-      url: endpoint,
-      method: method.toUpperCase(),
-      status: response.status
-    });
-
-    return response.data;
-  } catch (error) {
-    const axiosError = error as { response?: { status: number; data: unknown } };
-    const status = axiosError.response?.status;
-    const responseData = axiosError.response?.data;
-
-    console.error({
-      ...options,
-      message: `Fail to retrieved data from ${callee}`,
-      url: endpoint,
-      method: method.toUpperCase(),
-      status,
-      response: responseData
-    });
-
-    throw new Error(`HTTP error! status: ${status}`);
-  }
-}

package/src/common/back/jira/get-sorted-releases.ts

@@ -1,40 +0,0 @@
-import semver from "semver";
-
-import { getJiraReleases } from "./jira-releases.js";
-
-/**
- * Returns all releases under the tag version for the given project and component.
- * @param projectId {string}
- * @param component {string}
- * @param tagVersion {string}
- */
-export async function getSortedReleases(projectId: string, component: string, tagVersion: string) {
-  const releases = await getJiraReleases(projectId);
-
-  const promises = releases
-    .filter((release) => {
-      release.version = release.name
-        .replace(component + "-", "")
-        .replace("version-", "")
-        .replace("v", "");
-      try {
-        return semver.lte(release.version, tagVersion);
-      } catch {
-        return false;
-      }
-    })
-    .sort((ra, rb) => {
-      return semver.rcompare(ra.version!, rb.version!);
-    });
-
-  const [current, ...others] = await Promise.all(promises);
-
-  return [
-    current,
-    ...others.filter((release) => {
-      return !release?.released;
-    })
-  ]
-    .filter(Boolean)
-    .reverse();
-}