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

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.ts

@@ -1,47 +0,0 @@
-import { jiraRequest } from "./jira-request.js";
-
-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);
-
-  if (!response || !Array.isArray(response)) {
-    return [];
-  }
-
-  return response as JiraRelease[];
-}
-
-export async function updateJiraRelease(release: JiraRelease) {
-  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.spec.ts

@@ -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-request.ts

@@ -1,29 +0,0 @@
-import axiosRetry from "axios-retry";
-
-import { getConfig } from "../../get-config.js";
-import { httpRequest } from "../http/http-request.js";
-
-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");
-
-  return httpRequest(jiraUrl, {
-    ...opts,
-    callee: "JIRA",
-    headers: {
-      ...opts.headers,
-      Authorization: `Basic ${auth}`
-    },
-    retries: 3,
-    retryDelay: axiosRetry.exponentialDelay
-  });
-}

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

@@ -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/back/jira/jira-search.ts

@@ -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: string, opts?: Record<string, unknown>) {
-  return jiraRequest("/rest/api/3/search/jql", {
-    params: {
-      ...(opts as Record<string, string>),
-      jql
-    }
-  });
-}

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

@@ -1,58 +0,0 @@
-import execa from "execa";
-import { bun } from "./bun.js";
-import { Cli } from "./cli.js";
-
-vi.mock("execa", () => {
-  const sync = vi.fn();
-  const execaMock = Object.assign(vi.fn(), { sync });
-  return { default: execaMock };
-});
-
-type ExecaMock = {
-  sync: { mockImplementation(fn: (...args: unknown[]) => unknown): void };
-  mockReturnValue(v: unknown): void;
-};
-
-const execaMock = execa as unknown as ExecaMock;
-
-execaMock.sync.mockImplementation((...args) => {
-  return {
-    stdout: `CMD: ${([] as unknown[]).concat(...(args as (string | string[])[]).filter((arg) => typeof arg === "string" || Array.isArray(arg))).join(" ")}`
-  };
-});
-execaMock.mockReturnValue({});
-
-describe("BunCli", () => {
-  beforeEach(() => {
-    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", () => {
-    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/bun.ts

@@ -1,33 +0,0 @@
-import { Cli } from "./cli.js";
-
-class BunCli extends Cli {
-  constructor() {
-    super("bun");
-  }
-
-  newVersion(version: string) {
-    return this.pm("version", "--no-git-tag-version", version);
-  }
-
-  pm(...args: string[]) {
-    return this.sync("pm", ...args);
-  }
-
-  run(...args: string[]) {
-    return super.run("run", ...args);
-  }
-
-  install(...args: string[]) {
-    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/cli.ts

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

@@ -1,141 +0,0 @@
-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 sync = vi.fn();
-  const execaMock = Object.assign(vi.fn(), { sync });
-  return { default: execaMock };
-});
-
-type ExecaMock = {
-  sync: { mockImplementation(fn: (...args: unknown[]) => unknown): void };
-  mockReturnValue(v: unknown): void;
-};
-
-const execaMock = execa as unknown as ExecaMock;
-
-execaMock.mockReturnValue({});
-
-execaMock.sync.mockImplementation((...args) => {
-  return {
-    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: unknown[]) => {
-      return `CMD: ${([] as unknown[]).concat(...(args as (string | string[])[]).filter((arg) => typeof arg === "string" || Array.isArray(arg))).join(" ")}`;
-    });
-  });
-  describe("tag", () => {
-    it("should run tag cmd", () => {
-      const result = docker.tag("tag-arg", "image");
-
-      expect(result).toEqual("CMD: docker tag tag-arg image");
-      expect(Cli.getRaw).toHaveBeenCalledWith("docker", ["tag", "tag-arg", "image"], {
-        cwd: process.cwd()
-      });
-    });
-  });
-  describe("login", () => {
-    it("should run login cmd", () => {
-      const result = docker.login("login-arg");
-
-      expect(result.stdout).toEqual("CMD: docker login login-arg");
-      expect(execa.sync).toHaveBeenCalledWith("docker", ["login", "login-arg"], {
-        cwd: process.cwd(),
-        stdio: "inherit"
-      });
-    });
-  });
-  describe("push", () => {
-    it("should run push cmd", async () => {
-      await docker.push("push-arg");
-
-      expect(execa).toHaveBeenCalledWith("docker", ["push", "push-arg"], {
-        cwd: process.cwd(),
-        stdio: "inherit"
-      });
-    });
-  });
-  describe("getToken", () => {
-    beforeEach(() => {
-      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");
-
-      expect(axios).toHaveBeenCalledWith({
-        method: "POST",
-        url: "https://hub.docker.com/v2/users/login/",
-        headers: {
-          Accept: "application/json",
-          "Content-Type": "application/json"
-        },
-        data: {
-          password: "password",
-          username: "username"
-        }
-      });
-      expect(token).toEqual("token");
-    });
-  });
-  describe("getTags", () => {
-    beforeEach(() => {
-      vi.mocked(axios).mockReturnValue({
-        data: {
-          results: [
-            {
-              name: "branch-1",
-              last_updated: new Date("2020-06-01")
-            }
-          ]
-        }
-      } as unknown as ReturnType<typeof axios>);
-    });
-    it("should get token", async () => {
-      const tags = await docker.getTags({
-        token: "token",
-        repository: "owner"
-      });
-
-      expect(tags).toEqual([
-        {
-          name: "branch-1",
-          last_updated: new Date("2020-06-01")
-        }
-      ]);
-      expect(axios).toHaveBeenCalledWith({
-        method: "GET",
-        url: "https://hub.docker.com/v2/repositories/owner/tags/?page=1&page_size=500",
-        headers: {
-          Accept: "application/json",
-          Authorization: "JWT token"
-        }
-      });
-    });
-  });
-  describe("deleteTag", () => {
-    it("should run delete Tag", async () => {
-      await docker.deleteTag("my-tag", {
-        token: "token",
-        repository: "owner"
-      });
-
-      expect(axios).toHaveBeenCalledWith({
-        headers: {
-          Accept: "application/json",
-          Authorization: "JWT token"
-        },
-        method: "DELETE",
-        url: "https://hub.docker.com/v2/repositories/owner/tags/my-tag/"
-      });
-    });
-  });
-});