@cmflow/cli 2.0.0-rc.1 → 2.0.0-rc.3

package/bin/cm-jira-releases.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+import commander from "commander";
+
+import { commands, runCommand } from "../src/index.js";
+
+commander
+  .usage("cm jira-releases [options]")
+  .alias("cm jira-releases")
+  .option("-c, --component <compoent>", "Jira component filter")
+  .option("-c, --project-id <projectId>", "Jira projectId filter")
+  .option("-u, --update", "Update jira releases status if it's necessary", (v, t) => t + 1, 0)
+  .option("-v, --verbose", "Enable verbose log", (v, t) => t + 1, 0)
+  .option("-t, --tag <tag>", "The tag version you want to check or/and update")
+  .parse(process.argv);
+
+runCommand(commands.JiraReleases, commander);

package/bin/cm.js

@@ -21,6 +21,7 @@ commander
   .command("rebase", "Rebase the current branch from production")
   .command("merge", "Merge current branch into PRODUCTION_BRANCH")
   .command("fetch", "Download objects and refs from repository (--all and --prune)")
+  .command("jira-releases", "Check jira releases status from given status (and update releases statuses if --update is set)")
   .command("clean", "Clean deployed docker image on Docker hub")
   .command("config", "Configure git workspace with expected information")
   .parse(process.argv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cmflow/cli",
-  "version": "2.0.0-rc.1",
+  "version": "2.0.0-rc.3",
   "description": "An awesome Git Flow",
   "author": "camfou",
   "license": "MIT",
@@ -38,9 +38,12 @@
     "fs-extra": "^10.1.0",
     "globby": "11.1.0",
     "has-yarn": "^2.1.0",
+    "https-proxy-agent": "7.0.6",
     "inquirer": "9.2.19",
     "listr": "0.14.3",
     "lodash": "4.17.21",
+    "moment": "^2.30.1",
+    "node-fetch": "3.3.2",
     "rxjs": "7.8.1",
     "semantic-release": ">=24.2.3",
     "semver": "7.7.1",
@@ -83,7 +86,8 @@
     "lint_ci": "eslint --format junit --output-file ./reports/eslint.xml",
     "lint_fix": "eslint --fix",
     "release": "node bin/cmrelease.js",
-    "release_dry_run": "node bin/cmrelease.js --dry-run"
+    "release_dry_run": "node bin/cmrelease.js --dry-run",
+    "jira_releases": "node --env-file=.env bin/cm.js jira-releases --project-id CMAB --component API --tag 0.3238.2 --verbose"
   },
   "husky": {
     "hooks": {

package/src/commands/index.js

@@ -2,6 +2,7 @@ export * from "./clean.js";
 export * from "./deploy.js";
 export * from "./fetch.js";
 export * from "./finish.js";
+export * from "./jira-releases.js";
 export * from "./merge.js";
 export * from "./push.js";
 export * from "./rebase.js";

package/src/commands/jira-releases.js

@@ -0,0 +1,86 @@
+import chalk from "chalk";
+import figures from "figures";
+import moment from "moment";
+
+import { jiraGetReleasesAndIssues } from "../common/back/jira/jira-get-releases-and-issues.js";
+import { jiraIssueMoveTo } from "../common/back/jira/jira-issue-move-to.js";
+import { updateJiraRelease } from "../common/back/jira/jira-releases.js";
+
+const TYPES = {
+  Story: "feat",
+  "Sous-tâche": "tech",
+  Bug: "fix"
+};
+
+export class JiraReleases {
+  mapContext(commander, context) {
+    return {
+      ...context,
+      projectId: commander.projectId,
+      update: commander.update,
+      component: commander.component,
+      tag: commander.tag.replace(/^version-/, "").replace(/^v/, "")
+    };
+  }
+
+  getTasks(context) {
+    if (!context.tag) {
+      console.log(chalk.red(figures.cross), "Missing tag version. Skipping release notes generation");
+      return [];
+    }
+
+    return [
+      {
+        title: `List all releases under ${context.tag} for ${context.component} component and ${context.projectId} project`,
+        task: async () => {
+          context.releases = await jiraGetReleasesAndIssues(context.projectId, context.component, context.tag);
+        }
+      },
+      {
+        title: `Update ${context.tag} on ${context.component} component`,
+        skip: () => !context.update,
+        task: async () => {
+          for (const release of context.releases) {
+            release.released = true;
+            release.releaseDate = moment().format("YYYY-MM-DD");
+
+            await updateJiraRelease(release);
+
+            await Promise.all(
+              release.issues.map((issue) => {
+                return jiraIssueMoveTo(issue, {
+                  id: "18",
+                  name: "Livré en production"
+                });
+              })
+            );
+          }
+        }
+      }
+    ];
+  }
+
+  success(context) {
+    console.log(chalk.green(figures.tick), "Release notes generated successfully");
+    console.log("\n");
+
+    const note = `Bonjour,
+Nous allons livrer en production la version ${context.tag} de l'${context.component}
+Au menu de cette livraison :
+
+${context.releases
+  .map((release) => {
+    const issues = release.issues.map((issue) => {
+      return ` - ${TYPES[issue.fields.issuetype.name] || issue.fields.issuetype}(${issue.key}): ${issue.fields.summary}`;
+    });
+
+    return (context.releases.length > 1 ? "- v" + release.version + ":\n" : "") + issues.join(",\n");
+  })
+  .join("\n\n")}
+
+L'équipe API
+    `;
+
+    console.log(note);
+  }
+}

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

@@ -0,0 +1,15 @@
+import { HttpsProxyAgent } from "https-proxy-agent";
+
+import { getConfig } from "../../get-config.js";
+
+const { HTTPS_PROXY } = getConfig();
+
+export const getHttpProxy = (opts) => {
+  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.js

@@ -0,0 +1,65 @@
+import fetch from "node-fetch";
+
+import { getHttpProxy } from "./http-proxy.js";
+
+// export type HttpRequestOptions = {
+//   rejectUnauthorized?: boolean;
+//   callee?: string;
+//   params?: Record<string, string>;
+// } & fetch.RequestInit;
+/**
+ * @typedef {Object & RequestInit} 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
+ */
+
+/**
+ *
+ * @param endpoint {string}
+ * @param options {HttpRequestOptions}
+ * @return {Promise<*>}
+ */
+export async function httpRequest(endpoint, options = {}) {
+  const { callee, headers, method = "get", params = {}, rejectUnauthorized } = options;
+  const agent = getHttpProxy({
+    rejectUnauthorized,
+    callee
+  });
+
+  const queryParams = new URLSearchParams(params);
+  const url = `${endpoint}${queryParams.size ? "?" + queryParams : ""}`;
+
+  const response = await fetch(url, {
+    method,
+    headers: {
+      ...headers,
+      "Content-Type": "application/json"
+    },
+    agent,
+    ...options
+  });
+
+  if (!response.ok) {
+    console.error({
+      ...options,
+      message: `Fail to retrieved data from ${callee}`,
+      url,
+      method,
+      status: response.status,
+      response: await response.json()
+    });
+    throw new Error(`HTTP error! status: ${response.status}`);
+  }
+
+  console.info({
+    message: `Successfully retrieved data from ${callee}`,
+    url,
+    method,
+    status: response.status
+  });
+
+  return response.json();
+}

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

@@ -0,0 +1,47 @@
+import fetch from "node-fetch";
+
+import { getHttpProxy } from "./http-proxy.js";
+import { httpRequest } from "./http-request.js";
+
+vi.mock("node-fetch");
+vi.mock("./http-proxy.js");
+
+describe("httpRequest", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("should create an agent in production with proxy", async () => {
+    vi.mocked(fetch).mockResolvedValue({
+      status: 200,
+      headers: { "content-type": "application/json" },
+      ok: true,
+      async json() {
+        return { data: "test" };
+      }
+    });
+
+    const result = await httpRequest("http://example.com/test-endpoint", {
+      callee: "test"
+    });
+
+    expect(getHttpProxy).toHaveBeenCalledWith({
+      rejectUnauthorized: undefined,
+      callee: "test"
+    });
+    expect(result).toEqual({ data: "test" });
+  });
+
+  it("should throw an error if the response is not ok", async () => {
+    vi.mocked(fetch).mockResolvedValue({
+      status: 500,
+      headers: { "content-type": "application/json" },
+      ok: false,
+      async json() {
+        return { data: "test" };
+      }
+    });
+
+    await expect(httpRequest("http://example.com/test-endpoint", { callee: "test" })).rejects.toThrow("HTTP error! status: 500");
+  });
+});

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

@@ -0,0 +1,100 @@
+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-get-releases-and-issues.js

@@ -0,0 +1,33 @@
+import semver from "semver";
+
+import { getJiraReleases, getJiraVersionRelatedIssues } 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 jiraGetReleasesAndIssues(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;
+      }
+    })
+    .map(async (release) => {
+      const { issues } = await getJiraVersionRelatedIssues(projectId, release.name);
+      release.issues = issues;
+      return release;
+    });
+
+  return Promise.all(promises);
+}

package/src/common/back/jira/jira-issue-move-to.js

@@ -0,0 +1,39 @@
+import { jiraRequest } from "./jira-request.js";
+
+/**
+ * Moves a JIRA issue to the correct state using the specified transition.
+ * @param issue
+ * @param toTransition
+ * @return {Promise<void>}
+ */
+export async function jiraIssueMoveTo(issue, toTransition) {
+  /**
+   * {
+   *       transitions: {
+   *         id: string;
+   *         name: string;
+   *         to: { id: string; name: string };
+   *       }[];
+   *     }
+   */
+  const { transitions } = await jiraRequest(`/rest/api/3/issue/${issue.key}/transitions`);
+  const transition = transitions.find((transition) => {
+    return transition.id === toTransition.id;
+  });
+
+  if (transition) {
+    await jiraRequest(`/rest/api/3/issue/${issue.key}/transitions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      },
+      body: JSON.stringify({
+        transition: {
+          id: transition.id,
+          notifyUsers: false
+        }
+      })
+    });
+  }
+}

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

@@ -0,0 +1,38 @@
+import { jiraRequest } from "./jira-request.js";
+import { jiraSearch } from "./jira-search.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}`;
+
+  await jiraRequest(endpoint, {
+    method: "PUT",
+    headers: {
+      "Content-Type": "application/json",
+      Accept: "application/json"
+    },
+    body: JSON.stringify({
+      id: release.id,
+      description: release.description,
+      name: release.name,
+      archived: release.archived,
+      released: release.released,
+      projectId: release.projectId,
+      releaseDate: release.releaseDate
+    })
+  });
+}
+
+export async function getJiraVersionRelatedIssues(projectId, tagVersion) {
+  return jiraSearch(`project = "${projectId}" AND fixVersion="${tagVersion}" ORDER BY created DESC`);
+}

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

@@ -0,0 +1,17 @@
+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}`
+    }
+  });
+}

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

@@ -0,0 +1,53 @@
+import { httpRequest } from "../http/http-request.js";
+import { jiraRequest } from "./jira-request.js";
+
+vi.mock("../http/http-request.js");
+
+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" }
+    });
+
+    expect(httpRequest).toHaveBeenCalledWith(expect.stringContaining("/test-endpoint"), {
+      callee: "JIRA",
+      method: "post",
+      params: { key: "value" },
+      headers: expect.objectContaining({
+        Authorization: expect.stringContaining("Basic ")
+      })
+    });
+    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

@@ -0,0 +1,17 @@
+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", {
+    params: {
+      ...opts,
+      jql
+    }
+  });
+}

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

@@ -0,0 +1,43 @@
+import { jiraRequest } from "./jira-request.js";
+import { jiraSearch } from "./jira-search.js";
+
+vi.mock("./jira-request.js");
+
+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", {
+      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", {
+      params: {
+        expand: "changelog",
+        jql
+      }
+    });
+    expect(result).toEqual(mockResponse);
+  });
+});

package/src/common/get-config.js

@@ -86,7 +86,11 @@ export function getConfig() {
     GIT_USER_NAME,
     GIT_USER_EMAIL,
     GITLAB_USER_EMAIL,
-    GITLAB_USER_NAME
+    GITLAB_USER_NAME,
+    JIRA_API,
+    JIRA_EMAIL,
+    JIRA_TOKEN,
+    HTTPS_PROXY
   } = process.env;
 
   const HAS_YARN = hasYarn();
@@ -129,6 +133,10 @@ export function getConfig() {
     GIT_USER_EMAIL: GIT_USER_EMAIL || GITLAB_USER_EMAIL,
     GIT_DISABLE_SSL,
     BUMP_METHOD,
+    JIRA_API,
+    JIRA_EMAIL,
+    JIRA_TOKEN,
+    HTTPS_PROXY,
     WORKSPACES: pkg.workspaces || [],
     ...getCI()
   };