@cmflow/cli 2.0.0-alpha.9 → 2.0.0-rc.2

package/README.md

@@ -1,4 +1,4 @@
-<h1 style="text-align: center" align="center">CMFLOW</h1>
+<h1 style="text-align: center" align="center">@clubmed/cli aka ClubMed Flow </h1>
 
 <div align="center">
 
@@ -47,64 +47,63 @@ Then create `release.config.js` with this configuration:
 import { defineConfig } from '@cmflow/cli'
 
 export default defineConfig({
-  verifyConditions: ['@cmflow/cli/semantic/verify-conditions'],
-  analyzeCommits: ['@cmflow/cli/semantic/analyze-commits'],
-  verifyRelease: ['@cmflow/cli/semantic/verify-release'],
+  verifyConditions: ['@cmflow/cli/semantic/core/verify-conditions'],
+  analyzeCommits: ['@cmflow/cli/semantic/core/analyze-commits'],
+  verifyRelease: ['@cmflow/cli/semantic/core/verify-release'],
   generateNotes: [
     [
       "@cmflow/cli/semantic/conditional", // add this task to trigger build npm task
       {
         // when: (context) => context.branch.type === "release" //  default condition to run the task
-        run: ["@semantic-release/release-notes-generator"]
+        run: ["@semantic-release/core/release-notes-generator"]
       }
     ]
   ],
   prepare: [
-    '@cmflow/cli/semantic/prepare/bump-version',
+    '@cmflow/cli/semantic/core/prepare/bump-version',
     [
-      '@cmflow/cli/semantic/prepare/run', // add this task to trigger build npm task
+      '@cmflow/cli/semantic/core/prepare/run', // add this task to trigger build npm task
       {
         command: 'build'
       }
     ],
     [
-      '@cmflow/cli/semantic/prepare/run', // add this task to trigger build npm task
+      '@cmflow/cli/semantic/core/prepare/run', // add this task to trigger build npm task
       {
         command: 'test_e2e'
       }
     ],
     [
-      '@cmflow/cli/semantic/conditional', // add this task to trigger build npm task
+      '@cmflow/cli/semantic/core/conditional', // add this task to trigger build npm task
       {
         // when: (context) => context.branch.type === "release" //  default condition to run the task
         run:  [
-          '@cmflow/semantic/core/prepare/commit'
+          '@cmflow/cli/semantic/core/prepare/commit'
         ]
       }
     ]
   ],
   publish: [
     [
-      '@cmflow/cli/semantic/conditional',
+      '@cmflow/cli/semantic/core/conditional',
       {
         // when: (context) => context.branch.type === "release" //  default condition to run the task
         run: [
-          '@cmflow/cli/semantic/publish/sync-repository',
+          '@cmflow/cli/semantic/core/sync-repository',
           '@semantic-release/github'
         ] // only run if the conditional rule is true
       }
     ],
     [
-      '@cmflow/cli/semantic/conditional', // run process.exit(0) if the branch is not a release branch - legacy: maybe not necessary now all task are conditional
+      '@cmflow/cli/semantic/core/exit', // run process.exit(0) if the branch is not a release branch - legacy: maybe not necessary now all task are conditional
       {
-        when: (context) => context.branch.type !== 'release',
-        run: '@cmflow/cli/semantic/publish/exit.js'
+        when: (context) => context.nextRelease.channel === 'prerelease'
       }
     ]
   ],
   success: [
     [
-      '@cmflow/cli/semantic/conditional',
+      '@cmflow/cli/semantic/core/conditional',
       {
         // when: (context) => context.branch.type === "release" //  default condition to run the task
         run: '@semantic-release/github' // only run if the conditional rule is true
@@ -113,7 +112,7 @@ export default defineConfig({
   ],
   fail: [
     [
-      "@cmflow/cli/semantic/conditional",
+      "@cmflow/cli/semantic/core/conditional",
       {
         // when: (context) => context.branch.type === "release" //  default condition to run the task
         run: '@semantic-release/github' // only run if the conditional rule is true
@@ -139,7 +138,7 @@ Now, CmFlow and semantic release are correctly installed on your project.
 
 ### Condition step (publish, success, fail)
 
-CMFlow provide a `@cmflow/cli/semantic/conditional` task to run one task or many task only if a condition is true. The condition is a
+CMFlow provide a `@cmflow/cli/semantic/core/conditional` task to run one task or many task only if a condition is true. The condition is a
 function that takes the semantic context as parameter and return a boolean. 
 
 You can customize the condition to run the task by adding a `when` property to the configuration object.
@@ -147,7 +146,7 @@ You can customize the condition to run the task by adding a `when` property to t
 ```javascript
 export default defineConfig({
   publish: [
-    '@cmflow/cli/semantic/conditional',
+    '@cmflow/cli/semantic/core/conditional',
     {
       when: (context) => context.branch.type === 'release', //  default condition to run the task
       run: ['@semantic-release/github', '@semantic-release/github'] // only run if the conditional rule is true
@@ -172,6 +171,26 @@ Example:
   }
 }
 ```
+Then:
+
+```javascript
+export default defineConfig({
+  prepare: [
+    [
+      '@cmflow/cli/semantic/core/run',
+      {
+        command: 'build'
+      }
+    ],
+    [
+      '@cmflow/cli/semantic/core/run',
+      {
+        command: 'test_e2e'
+      }
+    ]
+  ]
+})
+```
 
 ### Generate release.info file 
 
@@ -202,33 +221,21 @@ import { defineConfig } from '@cmflow/cli'
 
 export default defineConfig({
   publish: [
-    [
-      '@cmflow/cli/semantic/conditional',
-      {
-        run: '@semantic-release/github'
-      }
-    ],
     '@cmflow/cli/semantic/docker/publish'
   ]
 });
 ```
 
-### Clean docker tags
+### Publish & Clean docker tags
 
 ```js
 import { defineConfig } from '@cmflow/cli'
 
 export default defineConfig({
   success: [
-    [
-      '@cmflow/cli/semantic/success',
-      {
-        runAfter: '@semantic-release/github' // only run if the conditional rule is true
-      }
-    ],
-    '@cmflow/cli/semantic/docker/publish'
+    '@cmflow/cli/semantic/docker/success'
   ]
-});
+})
 ```
 
 ### Configure CI

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-alpha.9",
+  "version": "2.0.0-rc.2",
   "description": "An awesome Git Flow",
   "author": "camfou",
   "license": "MIT",
@@ -26,9 +26,7 @@
   },
   "exports": {
     ".": "./src/index.js",
-    "./semantic/prepare/*": "./src/semantic/core/prepare/*.js",
-    "./semantic/*": "./src/semantic/core/*.js",
-    "./semantic/docker/*": "./src/semantic/docker/*.js"
+    "./semantic/*": "./src/semantic/*.js"
   },
   "dependencies": {
     "any-observable": "0.5.1",
@@ -40,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",
@@ -85,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/release.config.mjs

@@ -31,7 +31,7 @@ export default defineConfig({
     ]
   ],
   prepare: ["./src/semantic/core/prepare/bump-version.js", "./src/semantic/core/prepare/commit.js"],
-  publish: ["./src/semantic/core/publish/sync-repository.js", "@semantic-release/github"],
+  publish: ["./src/semantic/core/sync-repository.js", "@semantic-release/github"],
   success: ["@semantic-release/github"],
   fail: ["@semantic-release/github"],
   npmPublish: false

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
+    };
+  }
+
+  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/configure-git-workspace.js

@@ -3,7 +3,7 @@ import { git } from "./cli/git.js";
 export function configureGitWorkspace(context) {
   const {
     logger,
-    config: { SCM_TOKEN, REPOSITORY_URL, ORIGIN, GIT_USER_NAME, GIT_USER_EMAIL }
+    config: { SCM_TOKEN, REPOSITORY_URL, ORIGIN, GIT_USER_NAME, GIT_USER_EMAIL, GIT_DISABLE_SSL }
   } = context;
 
   if (GIT_USER_NAME && GIT_USER_EMAIL) {
@@ -11,6 +11,11 @@ export function configureGitWorkspace(context) {
     git.config("--global", "user.email", `"${GIT_USER_EMAIL}"`);
   }
 
+  if (GIT_DISABLE_SSL) {
+    logger.info("Disable SSL verification");
+    git.config("--global", "http.sslVerify", "false");
+  }
+
   if (SCM_TOKEN) {
     const repository = REPOSITORY_URL.replace("https://", "");
 

package/src/common/get-config.js

@@ -74,8 +74,24 @@ export function getCI() {
 export function getConfig() {
   const pkg = getPackageJson();
   const [owner, projectName] = pkg.name.replace(/^@/, "").split("/");
-  const { PROJECT_NAME, DOCKER_HUB_ID, DOCKER_HUB_PWD, REF_COMMIT, GH_TOKEN, SCM_TOKEN, REPOSITORY_URL, GIT_USER_NAME, GIT_USER_EMAIL } =
-    process.env;
+  const {
+    PROJECT_NAME,
+    DOCKER_HUB_ID,
+    DOCKER_HUB_PWD,
+    REF_COMMIT,
+    GH_TOKEN,
+    SCM_TOKEN,
+    REPOSITORY_URL,
+    GIT_DISABLE_SSL,
+    GIT_USER_NAME,
+    GIT_USER_EMAIL,
+    GITLAB_USER_EMAIL,
+    GITLAB_USER_NAME,
+    JIRA_API,
+    JIRA_EMAIL,
+    JIRA_TOKEN,
+    HTTPS_PROXY
+  } = process.env;
 
   const HAS_YARN = hasYarn();
   const IS_YARN_BERRY = HAS_YARN ? fs.existsSync(join(process.cwd(), ".yamlrc.yml")) : false;
@@ -113,9 +129,14 @@ export function getConfig() {
     GH_TOKEN,
     SCM_TOKEN: GH_TOKEN || SCM_TOKEN,
     REPOSITORY_URL: get(pkg, "repository.url", get(pkg, "repository", REPOSITORY_URL)),
-    GIT_USER_NAME,
-    GIT_USER_EMAIL,
+    GIT_USER_NAME: GIT_USER_NAME || GITLAB_USER_NAME,
+    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()
   };

package/src/semantic/core/conditional.js

@@ -23,9 +23,14 @@ export function fail(pluginConfig, context) {
 async function runAll(step, pluginConfig, context, defaultCondition) {
   context.config = getConfig();
 
-  const condition = pluginConfig.when !== undefined ? pluginConfig.if(context) : defaultCondition;
+  const condition = pluginConfig.when !== undefined ? pluginConfig.when(context) : defaultCondition;
 
-  if (condition && pluginConfig.run) {
+  if (!condition) {
+    context.logger.info(`Skip step "${step}" of plugin(s) "${pluginConfig.run}"`);
+    return;
+  }
+
+  if (pluginConfig.run) {
     const tasks = [].concat(pluginConfig.run);
 
     for (const task of tasks) {
@@ -34,7 +39,15 @@ async function runAll(step, pluginConfig, context, defaultCondition) {
         const taskFunction = mod[step];
 
         if (taskFunction) {
-          await taskFunction(pluginConfig, context);
+          context.logger.log(`   Start conditional step "${step}" of plugin "${task}"`);
+
+          try {
+            await taskFunction(pluginConfig, context);
+            context.logger.success(`   Completed conditional step "${step}" of plugin "${task}"`);
+          } catch (er) {
+            context.logger.fail(`   Fail conditional step "${step}" of plugin "${task}"`);
+            throw er;
+          }
         }
       }
     }

package/src/semantic/core/exit.js

@@ -0,0 +1,14 @@
+import { getConfig } from "../../common/index.js";
+
+export default async function exit(pluginConfig, context) {
+  context.config = getConfig();
+  const condition = pluginConfig.when !== undefined ? pluginConfig.when(context) : true;
+
+  if (condition) {
+    // avoid next semantic-release steps when is a prerelease or release branch with SKIP_GITHUB_PUBLISH
+    context.logger.success("Skip next semantic-release steps");
+    process.exit(0);
+  } else {
+    context.logger.success("Continue next semantic-release steps");
+  }
+}

package/src/semantic/core/{prepare/run.js → run.js}

@@ -1,11 +1,11 @@
-import { getConfig, npm, yarn } from "../../../common/index.js";
+import { getConfig, npm, yarn } from "../../common/index.js";
 
 /**
  * @param pluginConfig {{command: string}}
  * @param context
  * @return {Promise<void>}
  */
-export async function prepare(pluginConfig, context) {
+export default async function runCommand(pluginConfig, context) {
   context.config = getConfig();
   const {
     config: { HAS_YARN },

package/src/semantic/core/{publish/sync-repository.js → sync-repository.js}

@@ -1,6 +1,6 @@
-import { getConfig, git } from "../../../common/index.js";
+import { getConfig, git } from "../../common/index.js";
 
-export async function publish(pluginConfig, context) {
+export default async function syncRepository(pluginConfig, context) {
   context.config = getConfig();
 
   const {

package/src/semantic/define-config.js

@@ -30,34 +30,8 @@ export function defineConfig(opts = {}) {
     generateNotes: ["@cmflow/cli/semantic/generate-notes"],
     prepare: [
       "@cmflow/cli/semantic/prepare/bump-version",
-      // '@cmflow/cli/semantic/prepare/build',
-      // '@cmflow/cli/semantic/prepare/e2e',
       "@cmflow/cli/semantif/prepare/post" // need to avoid semantic next step
     ],
-    publish: [
-      [
-        "@cmflow/cli/semantic/publish",
-        {
-          runAfter: opts.runAfter
-        }
-      ]
-    ],
-    success: [
-      [
-        "@cmflow/cli/semantic/success",
-        {
-          runAfter: opts.runAfter
-        }
-      ]
-    ],
-    fail: [
-      [
-        "@cmflow/cli/semantic/fail",
-        {
-          runAfter: opts.runAfter
-        }
-      ]
-    ],
     releaseRules,
     parserOpts: {
       noteKeywords: ["BREAKING CHANGE", "BREAKING CHANGES"]

package/src/semantic/core/publish/exit.js

@@ -1,7 +0,0 @@
-import { getConfig } from "../../../common/index.js";
-
-export async function prepare(pluginConfig, context) {
-  context.config = getConfig();
-  // avoid next semantic-release steps when is a prerelease or release branch with SKIP_GITHUB_PUBLISH
-  process.exit(0);
-}