@cmflow/cli 3.3.0 → 3.4.0-alpha.3

package/src/common/back/http/http-request.js

@@ -1,77 +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
- */
-
-/**
- * @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)
- */
-
-/**
- *
- * @param endpoint {string}
- * @param options {HttpRequestOptions}
- * @return {Promise<*>}
- */
-export async function httpRequest(endpoint, options = {}) {
-  const { callee, headers, method = "get", params = {}, rejectUnauthorized, ...rest } = options;
-  const httpsAgent = getHttpProxy({
-    rejectUnauthorized,
-    callee
-  });
-
-  const instance = axios.create();
-
-  axiosRetry(instance, options);
-
-  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 status = error.response?.status;
-    const responseData = error.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/http/http-request.spec.js

@@ -1,49 +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;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockInstance = vi.fn();
-    vi.mocked(axios.create).mockReturnValue(mockInstance);
-  });
-
-  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 = new Error("Request failed");
-    axiosError.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/jira/get-sorted-releases.js

@@ -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, component, tagVersion) {
-  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();
-}

package/src/common/back/jira/interfaces/JiraIIssue.d.ts

@@ -1,100 +0,0 @@
-import type { ADFDocument } from "./ADFDocument.js";
-import type { JiraChangelog } from "./JiraChangelogIssueResponse.js";
-
-export interface JiraStatus {
-  id: string;
-  name: string;
-}
-
-export interface JiraUser {
-  accountId?: string;
-  displayName?: string;
-  emailAddress?: string;
-}
-
-export interface CreateJiraComment {
-  body: ADFDocument;
-  author: JiraUser;
-  notifyUsers?: boolean;
-}
-
-export interface JiraComment extends CreateJiraComment {
-  id: string;
-  body: ADFDocument;
-  author: JiraUser;
-  created: string;
-  updated?: string;
-}
-
-interface JiraAttachment {
-  id: string;
-  filename: string;
-  content: string; // URL de téléchargement
-  size: number;
-  mimeType?: string;
-  created: string;
-  author: JiraUser;
-}
-
-interface JiraIssueLink {
-  id: string;
-  type: {
-    id: string;
-    name: string; // Ex: "relates to", "blocks"
-    inward: string; // Ex: "is blocked by"
-    outward: string; // Ex: "blocks"
-  };
-  inwardIssue?: Partial<JiraIssue>; // Issue liée en amont
-  outwardIssue?: Partial<JiraIssue>; // Issue liée en aval
-}
-
-export interface CreateJiraFieldsIssue {
-  summary: string; // Titre de l'issue
-  description?: ADFDocument; // Description détaillée
-  labels?: string[]; // Liste des labels
-  issuetype: {
-    name: string; // Type d'issue (ex: "Bug", "Task")
-  };
-  project: {
-    key: string;
-  };
-  assignee?: Partial<JiraUser>; // Utilisateur assigné
-  reporter?: Partial<JiraUser>; // Créateur de l'issue
-  status?: Omit<JiraStatus, "name">;
-  components?: { name: string }[];
-
-  [customFieldId: `customfield_${string}`]: unknown; // Autres champs personnalisés
-}
-
-export interface CreateJiraIssue {
-  fields: CreateJiraFieldsIssue;
-}
-
-export interface JiraIssue {
-  id: string; // ID unique de l'issue
-  key: string; // Clé de l'issue (ex: "PROJ-123")
-  self: string; // URL de l'issue
-
-  fields: CreateJiraFieldsIssue & {
-    issuetype: {
-      id: string;
-      name: string; // Type d'issue (ex: "Bug", "Task")
-    };
-    project: {
-      id: string;
-      key: string;
-      name: string;
-    };
-    comment?: {
-      comments: JiraComment[];
-      total: number;
-    };
-    status: JiraStatus;
-    attachment?: JiraAttachment[]; // Liste des pièces jointes
-    issuelinks?: JiraIssueLink[]; // Relations avec d'autres issues
-    created: string; // Date de création
-    updated: string; // Dernière mise à jour
-  };
-}
-
-export type JiraIssueWithChangelog = JiraIssue & { changelog: JiraChangelog };

package/src/common/back/jira/jira-releases.js

@@ -1,36 +0,0 @@
-import { jiraRequest } from "./jira-request.js";
-
-export async function getJiraReleases(projectId) {
-  const endpoint = `/rest/api/3/project/${projectId}/versions?expand`;
-  const response = await jiraRequest(endpoint);
-
-  if (!response || !Array.isArray(response)) {
-    return [];
-  }
-
-  return response;
-}
-
-export async function updateJiraRelease(release) {
-  const endpoint = `/rest/api/3/version/${release.id}`;
-  try {
-    await jiraRequest(endpoint, {
-      method: "put",
-      headers: {
-        "Content-Type": "application/json",
-        Accept: "application/json"
-      },
-      data: {
-        id: release.id,
-        description: release.description,
-        name: release.name,
-        archived: release.archived,
-        released: release.released,
-        projectId: release.projectId,
-        releaseDate: release.releaseDate
-      }
-    });
-  } catch (er) {
-    console.log(`Error while updating jira release ${release.id}`, er);
-  }
-}

package/src/common/back/jira/jira-request.js

@@ -1,21 +0,0 @@
-import axiosRetry from "axios-retry";
-
-import { getConfig } from "../../get-config.js";
-import { httpRequest } from "../http/http-request.js";
-
-export async function jiraRequest(endpoint, opts = {}) {
-  const { JIRA_API, JIRA_TOKEN, JIRA_EMAIL } = getConfig();
-  const jiraUrl = `${JIRA_API}${endpoint}`;
-  const auth = Buffer.from(`${JIRA_EMAIL}:${JIRA_TOKEN}`).toString("base64");
-
-  return httpRequest(jiraUrl, {
-    ...opts,
-    callee: "JIRA",
-    headers: {
-      ...opts.headers,
-      Authorization: `Basic ${auth}`
-    },
-    retries: 3,
-    retryDelay: axiosRetry.exponentialDelay
-  });
-}

package/src/common/back/jira/jira-request.spec.js

@@ -1,59 +0,0 @@
-import { httpRequest } from "../http/http-request.js";
-import { jiraRequest } from "./jira-request.js";
-
-vi.mock("../http/http-request.js");
-vi.mock("axios-retry");
-
-describe("jiraRequest", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it("should make a GET request to the JIRA API", async () => {
-    const mockResponse = { data: "test" };
-    vi.mocked(httpRequest).mockResolvedValue(mockResponse);
-
-    const result = await jiraRequest("/test-endpoint");
-
-    expect(httpRequest).toHaveBeenCalledWith(
-      expect.stringContaining("/test-endpoint"),
-      expect.objectContaining({
-        headers: expect.objectContaining({
-          Authorization: expect.stringContaining("Basic ")
-        })
-      })
-    );
-    expect(result).toEqual(mockResponse);
-  });
-
-  it("should make a POST request to the JIRA API", async () => {
-    const mockResponse = { data: "test" };
-    vi.mocked(httpRequest).mockResolvedValue(mockResponse);
-
-    const result = await jiraRequest("/test-endpoint", {
-      method: "post",
-      params: { key: "value" },
-      headers: { "Content-Type": "application/json" },
-      data: { key: "value" }
-    });
-
-    expect(httpRequest).toHaveBeenCalledWith(expect.stringContaining("/test-endpoint"), {
-      callee: "JIRA",
-      method: "post",
-      params: { key: "value" },
-      data: { key: "value" },
-      headers: expect.objectContaining({
-        Authorization: expect.stringContaining("Basic ")
-      }),
-      retries: 3,
-      retryDelay: expect.any(Function)
-    });
-    expect(result).toEqual(mockResponse);
-  });
-
-  it("should throw an error if the httpRequest fails", async () => {
-    vi.mocked(httpRequest).mockRejectedValue(new Error("Request failed"));
-
-    await expect(jiraRequest("test-endpoint")).rejects.toThrow("Request failed");
-  });
-});

package/src/common/back/jira/jira-search.js

@@ -1,17 +0,0 @@
-import { jiraRequest } from "./jira-request.js";
-
-/**
- * Search JIRA issues using JQL (JIRA Query Language).
- * @template Expand
- * @param jql {string} JIRA Query Language
- * @param opts {object} Options
- * @returns {Promise<{issues: (import("./interfaces/JiraIIssue.d.ts").JiraIssue & Expand)[], total: number, maxResults: number}>}
- */
-export function jiraSearch(jql, opts) {
-  return jiraRequest("/rest/api/3/search/jql", {
-    params: {
-      ...opts,
-      jql
-    }
-  });
-}

package/src/common/back/jira/jira-search.spec.js

@@ -1,44 +0,0 @@
-import { jiraRequest } from "./jira-request.js";
-import { jiraSearch } from "./jira-search.js";
-
-vi.mock("./jira-request.js");
-vi.mock("axios-retry");
-
-describe("jiraSearch", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it("should call jiraRequest with the correct JQL", async () => {
-    const mockResponse = { issues: [] };
-    vi.mocked(jiraRequest).mockResolvedValue(mockResponse);
-
-    const jql = "project = TEST";
-    const result = await jiraSearch(jql);
-
-    expect(jiraRequest).toHaveBeenCalledWith("/rest/api/3/search/jql", {
-      params: {
-        jql
-      }
-    });
-    expect(result).toEqual(mockResponse);
-  });
-
-  it("should call jiraRequest with the correct JQL and expend option", async () => {
-    const mockResponse = { issues: [] };
-    vi.mocked(jiraRequest).mockResolvedValue(mockResponse);
-
-    const jql = "project = TEST";
-    const result = await jiraSearch(jql, {
-      expand: "changelog"
-    });
-
-    expect(jiraRequest).toHaveBeenCalledWith("/rest/api/3/search/jql", {
-      params: {
-        expand: "changelog",
-        jql
-      }
-    });
-    expect(result).toEqual(mockResponse);
-  });
-});

package/src/common/cli/bun.js

@@ -1,33 +0,0 @@
-import { Cli } from "./cli.js";
-
-class BunCli extends Cli {
-  constructor() {
-    super("bun");
-  }
-
-  newVersion(version) {
-    return this.pm("version", "--no-git-tag-version", version);
-  }
-
-  pm(...args) {
-    return this.sync("pm", ...args);
-  }
-
-  run(...args) {
-    return super.run("run", ...args);
-  }
-
-  install(...args) {
-    return super.run("install", ...args);
-  }
-
-  /**
-   * Reinstall dependencies without bun.lock mutation
-   * @returns {Promise<unknown>}
-   */
-  restore() {
-    return super.run("install", "--frozen-lockfile");
-  }
-}
-
-export const bun = new BunCli();

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

@@ -1,51 +0,0 @@
-vi.mock("execa", () => {
-  const execaMock = vi.fn();
-  execaMock.sync = vi.fn();
-  return { default: execaMock };
-});
-
-const { default: execa } = await import("execa");
-const { bun } = await import("./bun.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("BunCli", () => {
-  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 = bun.newVersion("1.0.0");
-
-      expect(result.stdout).toEqual("CMD: bun pm version --no-git-tag-version 1.0.0");
-    });
-  });
-  describe("run", () => {
-    it('should run "run" cmd', async () => {
-      await bun.run("run-arg");
-
-      expect(execa).toHaveBeenCalledWith("bun", ["run", "run-arg"], {
-        cwd: process.cwd(),
-        stdio: "inherit"
-      });
-    });
-  });
-  describe("install", () => {
-    it('should run "install" cmd', async () => {
-      await bun.install("install-arg");
-
-      expect(execa).toHaveBeenCalledWith("bun", ["install", "install-arg"], {
-        cwd: process.cwd(),
-        stdio: "inherit"
-      });
-    });
-  });
-});

package/src/common/cli/cli.js

@@ -1,110 +0,0 @@
-import "any-observable/register/rxjs-all.js";
-
-import { spawnSync } from "child_process";
-import execa from "execa";
-import { filter, fromEvent, map, merge, takeUntil } from "rxjs";
-export class Cli {
-  constructor(cmd) {
-    this.cmd = cmd;
-  }
-
-  sync(...args) {
-    return Cli.run(this.cmd, args).sync();
-  }
-
-  run(...args) {
-    return Cli.run(this.cmd, args);
-  }
-
-  get(...args) {
-    return Cli.run(this.cmd, args).get();
-  }
-
-  static run(cmd, args = [], options = {}) {
-    const run = (opt = {}) => {
-      return execa(cmd, args, {
-        cwd: process.cwd(),
-        ...opt,
-        ...options
-      });
-    };
-
-    let isPromise = true;
-
-    const promise = new Promise((resolve, reject) => {
-      setTimeout(async () => {
-        if (isPromise) {
-          try {
-            const result = await run({
-              stdio: "inherit"
-            });
-
-            resolve(result);
-          } catch (err) {
-            reject(err);
-          }
-        } else {
-          resolve();
-        }
-      }, 10);
-    });
-
-    promise.toObservable = (opt) => {
-      isPromise = false;
-      const cp = run(opt);
-      const end$ = fromEvent(cp, "close");
-      const stdout$ = fromEvent(cp.stdout, "data").pipe(
-        takeUntil(end$),
-        map((data) => data.toString())
-      );
-      const stderr$ = fromEvent(cp.stderr, "data").pipe(
-        takeUntil(end$),
-        map((data) => data.toString())
-      );
-
-      return merge(stdout$, stderr$).pipe(filter(Boolean));
-    };
-
-    promise.toStream = (opt) => {
-      isPromise = false;
-
-      return run(opt);
-    };
-
-    promise.cwd = (cwd) => {
-      options.cwd = cwd;
-      return promise;
-    };
-
-    promise.sync = (opt) => {
-      isPromise = false;
-      return execa.sync(cmd, args, {
-        cwd: process.cwd(),
-        stdio: "inherit",
-        ...options,
-        ...opt
-      });
-    };
-
-    promise.getRaw = (opt) => {
-      isPromise = false;
-      return Cli.getRaw(cmd, args, {
-        cwd: process.cwd(),
-        ...options,
-        ...opt
-      });
-    };
-
-    promise.get = promise.getRaw;
-
-    return promise;
-  }
-
-  static getRaw(cmd, args, options) {
-    return spawnSync(cmd, args, options)
-      .output.filter((o) => !!o)
-      .map((o) => o.toString())
-      .join("\n")
-      .trim();
-  }
-}