@uxf/scripts 11.123.0 → 11.124.0

package/README.md

@@ -19,7 +19,7 @@ Most binaries are already available in the UXF Docker images, so CI jobs can cal
 yarn add -D @uxf/scripts
 ```
 
-Requires **Node.js >= 24** (`engines.node`). No peer dependencies. Runtime dependencies (`axios`, `cheerio`, `dayjs`, `fast-glob`, `got`, `madge`, `robots-txt-parser`, `semver`, `yaml`, `yargs`) are bundled.
+Requires **Node.js >= 24** (`engines.node`). No peer dependencies. Runtime dependencies (`axios`, `cheerio`, `dayjs`, `fast-glob`, `got`, `rev-dep`, `robots-txt-parser`, `semver`, `yaml`, `yargs`) are bundled.
 
 ## Commands
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@uxf/scripts",
-    "version": "11.123.0",
+    "version": "11.124.0",
     "description": "",
     "main": "index.js",
     "bin": {
@@ -30,12 +30,11 @@
         "node": ">=24"
     },
     "dependencies": {
-        "axios": "^1.19.0",
         "cheerio": "1.2.0",
         "dayjs": "^1.11.21",
         "fast-glob": "3.3.3",
         "got": "15.1.0",
-        "madge": "8.0.0",
+        "rev-dep": "3.0.0",
         "robots-txt-parser": "2.0.3",
         "semver": "^7.8.5",
         "yaml": "2.9.0",
@@ -46,7 +45,7 @@
         "@types/react": "18.3.31",
         "@types/react-dom": "18.3.7",
         "@types/semver": "^7.7.1",
-        "@uxf/core": "11.123.0",
-        "@uxf/ui": "11.123.0"
+        "@uxf/core": "11.124.0",
+        "@uxf/ui": "11.124.0"
     }
 }

package/src/cli-args.js

@@ -0,0 +1,43 @@
+/**
+ * Drobná náhrada yargsu pro notifiery, které musí běžet v CI bez `npm install`
+ * — viz `docs/decisions/package-manager.md`. Ostatní skripty v balíčku yargs
+ * používají dál; tenhle helper řeší jen `--help` a jednu hodnotovou option.
+ */
+
+/**
+ * @param {string[]} args
+ * @param {string[]} names např. `["-h", "--help"]`
+ */
+function hasFlag(args, names) {
+    return args.some((arg) => names.includes(arg));
+}
+
+/**
+ * Přečte hodnotu option ve tvaru `--name value`, `--name=value`, `-n value` i `-n=value`.
+ *
+ * @param {string[]} args
+ * @param {string[]} names např. `["-g", "--google-chat-webhook-url"]`
+ * @returns {string | undefined}
+ */
+function readOption(args, names) {
+    for (let index = 0; index < args.length; index++) {
+        const arg = args[index];
+
+        if (names.includes(arg)) {
+            return args[index + 1];
+        }
+
+        const matched = names.find((name) => arg.startsWith(`${name}=`));
+
+        if (matched) {
+            return arg.slice(matched.length + 1);
+        }
+    }
+
+    return undefined;
+}
+
+module.exports = {
+    hasFlag,
+    readOption,
+};

package/src/cli-args.test.js

@@ -0,0 +1,61 @@
+const { hasFlag, readOption } = require("./cli-args");
+
+describe("hasFlag", () => {
+    it("finds the long form", () => {
+        expect(hasFlag(["--help"], ["-h", "--help"])).toBe(true);
+    });
+
+    it("finds the short form", () => {
+        expect(hasFlag(["-h"], ["-h", "--help"])).toBe(true);
+    });
+
+    it("finds the flag among other arguments", () => {
+        expect(hasFlag(["-g", "https://x", "--help"], ["-h", "--help"])).toBe(true);
+    });
+
+    it("returns false when absent", () => {
+        expect(hasFlag(["-g", "https://x"], ["-h", "--help"])).toBe(false);
+        expect(hasFlag([], ["-h", "--help"])).toBe(false);
+    });
+
+    it("does not match a flag that is only a prefix", () => {
+        expect(hasFlag(["--help-me"], ["-h", "--help"])).toBe(false);
+    });
+});
+
+describe("readOption", () => {
+    const NAMES = ["-g", "--google-chat-webhook-url"];
+
+    it("reads `--name value`", () => {
+        expect(readOption(["--google-chat-webhook-url", "https://x"], NAMES)).toBe("https://x");
+    });
+
+    it("reads `--name=value` — the form used in .gitlab-ci.yml", () => {
+        expect(readOption(["--google-chat-webhook-url=https://x"], NAMES)).toBe("https://x");
+    });
+
+    it("reads `-n value`", () => {
+        expect(readOption(["-g", "https://x"], NAMES)).toBe("https://x");
+    });
+
+    it("reads `-n=value`", () => {
+        expect(readOption(["-g=https://x"], NAMES)).toBe("https://x");
+    });
+
+    it("keeps `=` inside the value", () => {
+        expect(readOption(["--google-chat-webhook-url=https://x?key=abc"], NAMES)).toBe("https://x?key=abc");
+    });
+
+    it("finds the option among other arguments", () => {
+        expect(readOption(["--verbose", "-g", "https://x", "--other"], NAMES)).toBe("https://x");
+    });
+
+    it("returns undefined when the option is missing", () => {
+        expect(readOption(["--verbose"], NAMES)).toBeUndefined();
+        expect(readOption([], NAMES)).toBeUndefined();
+    });
+
+    it("returns undefined when the option is last and has no value", () => {
+        expect(readOption(["-g"], NAMES)).toBeUndefined();
+    });
+});

package/src/{GitLab.js → gitlab.js}

@@ -1,24 +1,41 @@
 const { env } = require("process");
-const { create } = require("axios");
-const dayjs = require("dayjs");
+const { request } = require("./http");
 
-const axios = create({
-    baseURL: `${env.CI_SERVER_URL}/api/v4`,
-    headers: {
-        Authorization: `Bearer ${env.GITLAB_TOKEN}`,
-    },
-});
+/**
+ * @param {string} url
+ * @param {{method?: string, headers?: Record<string, string>, params?: Record<string, any>, body?: any}} options
+ */
+function gitlabRequest(url, options = {}) {
+    return request(url, {
+        ...options,
+        baseUrl: `${env.CI_SERVER_URL}/api/v4`,
+        headers: { Authorization: `Bearer ${env.GITLAB_TOKEN}`, ...options.headers },
+    });
+}
+
+/** Lokální čas, stejně jako `dayjs().format(...)`, které tohle nahradilo. */
+function formatTagTimestamp(date = new Date()) {
+    const pad = (value) => String(value).padStart(2, "0");
+
+    return [
+        date.getFullYear(),
+        pad(date.getMonth() + 1),
+        pad(date.getDate()),
+        pad(date.getHours()),
+        pad(date.getMinutes()),
+    ].join("-");
+}
 
 /**
  *
  * @param {string} url
- * @param {axios.AxiosRequestConfig<any>} config
+ * @param {{params?: Record<string, any>}} config
  */
 async function getAll(url, config) {
     let nextPage = "1";
     const data = [];
     do {
-        const response = await axios.get(url, {
+        const response = await gitlabRequest(url, {
             ...config,
             params: {
                 ...config.params,
@@ -26,7 +43,7 @@ async function getAll(url, config) {
                 page: nextPage,
             },
         });
-        nextPage = response.headers["x-next-page"];
+        nextPage = response.headers.get("x-next-page");
         data.push(...response.data);
     } while (nextPage);
 
@@ -38,15 +55,15 @@ async function loadCommits(from, ref_name = "master") {
 
     let nextPage = "1";
     do {
-        const response = await axios.get(`/projects/${env.CI_PROJECT_ID}/repository/commits`, {
+        const response = await gitlabRequest(`/projects/${env.CI_PROJECT_ID}/repository/commits`, {
             params: {
                 ref_name,
-                since: from ? dayjs(from).toISOString() : undefined,
+                since: from ? new Date(from).toISOString() : undefined,
                 per_page: "100",
                 page: nextPage,
             },
         });
-        nextPage = response.headers["x-next-page"];
+        nextPage = response.headers.get("x-next-page");
         commits.push(...response.data);
     } while (nextPage);
 
@@ -61,7 +78,7 @@ async function findMigrationFiles(commits) {
     await Promise.all(
         commits.map(async (commit) => {
             try {
-                const { data: diffs } = await axios.get(
+                const { data: diffs } = await gitlabRequest(
                     `/projects/${env.CI_PROJECT_ID}/repository/commits/${commit.id}/diff`,
                 );
                 diffs.forEach(({ new_path }) => {
@@ -81,7 +98,7 @@ async function findMigrationFiles(commits) {
 }
 
 async function getLastTag(tagPrefix = "release-", ref_name = "master") {
-    const { data: commits } = await axios.get(`/projects/${env.CI_PROJECT_ID}/repository/commits`, {
+    const { data: commits } = await gitlabRequest(`/projects/${env.CI_PROJECT_ID}/repository/commits`, {
         params: {
             ref_name,
             per_page: "100",
@@ -90,9 +107,11 @@ async function getLastTag(tagPrefix = "release-", ref_name = "master") {
 
     const commitIds = commits.map((commit) => commit.id);
 
-    const { data: tags } = await axios.get(`/projects/${env.CI_PROJECT_ID}/repository/tags`, {
+    // Pozor: `per_page` tu záměrně chybí. V axios verzi bylo omylem mimo `params`,
+    // takže se na GitLab nikdy neposlalo a platí default (20 tagů). Doplnit ho by
+    // změnilo, který tag se najde, což je zásah do release flow — řešit zvlášť.
+    const { data: tags } = await gitlabRequest(`/projects/${env.CI_PROJECT_ID}/repository/tags`, {
         params: { search: `^${tagPrefix}` },
-        per_page: "100",
     });
 
     const tag = tags.find((tag) => commitIds.includes(tag.commit.id)) ?? null;
@@ -107,20 +126,23 @@ async function getLastTag(tagPrefix = "release-", ref_name = "master") {
 }
 
 async function createRelease(description, tagPrefix = "release-", dryRun = false) {
-    const tag = tagPrefix + dayjs().format("YYYY-MM-DD-HH-mm");
+    const tag = tagPrefix + formatTagTimestamp();
 
     if (dryRun) {
         console.log(`\n🎉🎉🎉 Release "${tag}" published (skipped in dry run)\n\n${description}`);
         return;
     }
 
-    await axios.post(`/projects/${env.CI_PROJECT_ID}/releases`, { description, tag_name: tag, ref: "master" });
+    await gitlabRequest(`/projects/${env.CI_PROJECT_ID}/releases`, {
+        method: "POST",
+        body: { description, tag_name: tag, ref: "master" },
+    });
 
     console.log(`\n🎉🎉🎉 Release "${tag}" published\n\n${description}`);
 }
 
 function getSingleMergeRequestChanges(projectId, mr_iid) {
-    return axios.get(`/projects/${projectId}/merge_requests/${mr_iid}/changes`).then((r) => r.data);
+    return gitlabRequest(`/projects/${projectId}/merge_requests/${mr_iid}/changes`).then((r) => r.data);
 }
 
 /**

package/src/gitlab.test.js

@@ -0,0 +1,207 @@
+const GitLab = require("./gitlab");
+
+const originalFetch = globalThis.fetch;
+const { CI_SERVER_URL, GITLAB_TOKEN, CI_PROJECT_ID } = process.env;
+
+/**
+ * @param {Array<{body: any, nextPage?: string, status?: number}>} pages
+ * odpovědi v pořadí, v jakém je fetch vrátí
+ */
+function stubFetch(pages) {
+    const calls = [];
+    let index = 0;
+
+    globalThis.fetch = async (url, init) => {
+        calls.push({ url, init });
+        const page = pages[Math.min(index++, pages.length - 1)];
+        const status = page.status ?? 200;
+
+        return {
+            ok: status >= 200 && status < 300,
+            status,
+            headers: {
+                get: (name) => {
+                    if (name === "x-next-page") {
+                        return page.nextPage ?? "";
+                    }
+                    return name.toLowerCase() === "content-type" ? "application/json" : null;
+                },
+            },
+            text: async () => JSON.stringify(page.body),
+        };
+    };
+
+    return calls;
+}
+
+beforeEach(() => {
+    process.env.CI_SERVER_URL = "https://git.test";
+    process.env.GITLAB_TOKEN = "test-token";
+    process.env.CI_PROJECT_ID = "42";
+    jest.spyOn(console, "log").mockImplementation(() => {});
+});
+
+afterEach(() => {
+    globalThis.fetch = originalFetch;
+    process.env.CI_SERVER_URL = CI_SERVER_URL;
+    process.env.GITLAB_TOKEN = GITLAB_TOKEN;
+    process.env.CI_PROJECT_ID = CI_PROJECT_ID;
+    jest.restoreAllMocks();
+});
+
+describe("authentication and base url", () => {
+    it("prefixes the API path and sends the bearer token", async () => {
+        const calls = stubFetch([{ body: [] }]);
+
+        await GitLab.getAllProjects();
+
+        expect(calls[0].url).toContain("https://git.test/api/v4/projects");
+        expect(calls[0].init.headers.Authorization).toBe("Bearer test-token");
+    });
+});
+
+describe("getAll pagination", () => {
+    it("follows x-next-page until it is empty and concatenates the pages", async () => {
+        const calls = stubFetch([
+            { body: [{ id: 1 }], nextPage: "2" },
+            { body: [{ id: 2 }], nextPage: "3" },
+            { body: [{ id: 3 }], nextPage: "" },
+        ]);
+
+        const projects = await GitLab.getAllProjects();
+
+        expect(projects).toEqual([{ id: 1 }, { id: 2 }, { id: 3 }]);
+        expect(calls).toHaveLength(3);
+        expect(calls[0].url).toContain("page=1");
+        expect(calls[1].url).toContain("page=2");
+        expect(calls[2].url).toContain("page=3");
+    });
+
+    it("stops after a single page when there is no next page", async () => {
+        const calls = stubFetch([{ body: [{ id: 1 }] }]);
+
+        await GitLab.getAllProjects();
+
+        expect(calls).toHaveLength(1);
+    });
+
+    it("always asks for 100 items per page", async () => {
+        const calls = stubFetch([{ body: [] }]);
+
+        await GitLab.getAllProjects();
+
+        expect(calls[0].url).toContain("per_page=100");
+    });
+});
+
+describe("getAllMergeRequests", () => {
+    it("excludes work in progress by default", async () => {
+        const calls = stubFetch([{ body: [] }]);
+
+        await GitLab.getAllMergeRequests(false);
+
+        expect(calls[0].url).toContain("wip=no");
+    });
+
+    it("omits the wip filter when work in progress is included", async () => {
+        const calls = stubFetch([{ body: [] }]);
+
+        await GitLab.getAllMergeRequests(true);
+
+        expect(calls[0].url).not.toContain("wip=");
+    });
+});
+
+describe("loadCommits", () => {
+    it("converts the `from` timestamp to ISO for the `since` parameter", async () => {
+        const calls = stubFetch([{ body: [] }]);
+
+        await GitLab.loadCommits("2026-01-02T03:04:05.000Z");
+
+        expect(decodeURIComponent(calls[0].url)).toContain("since=2026-01-02T03:04:05.000Z");
+    });
+
+    it("omits `since` when there is no starting point", async () => {
+        const calls = stubFetch([{ body: [] }]);
+
+        await GitLab.loadCommits(null);
+
+        expect(calls[0].url).not.toContain("since=");
+    });
+
+    it("drops the boundary commit so the last release is not counted twice", async () => {
+        const from = "2026-01-02T03:04:05.000Z";
+        stubFetch([
+            {
+                body: [
+                    { id: "a", created_at: from },
+                    { id: "b", created_at: "2026-01-03T00:00:00.000Z" },
+                ],
+            },
+        ]);
+
+        const commits = await GitLab.loadCommits(from);
+
+        expect(commits.map((c) => c.id)).toEqual(["b"]);
+    });
+
+    it("uses the requested ref", async () => {
+        const calls = stubFetch([{ body: [] }]);
+
+        await GitLab.loadCommits(null, "develop");
+
+        expect(calls[0].url).toContain("ref_name=develop");
+    });
+});
+
+describe("getSingleMergeRequestChanges", () => {
+    it("returns the response body", async () => {
+        stubFetch([{ body: { changes_count: "7" } }]);
+
+        await expect(GitLab.getSingleMergeRequestChanges(1, 2)).resolves.toEqual({ changes_count: "7" });
+    });
+});
+
+describe("createRelease", () => {
+    it("builds a tag from the prefix and a local timestamp", async () => {
+        const calls = stubFetch([{ body: {} }]);
+
+        await GitLab.createRelease("poznámky", "release-");
+
+        expect(calls[0].init.method).toBe("POST");
+        expect(JSON.parse(calls[0].init.body)).toEqual({
+            description: "poznámky",
+            tag_name: expect.stringMatching(/^release-\d{4}-\d{2}-\d{2}-\d{2}-\d{2}$/),
+            ref: "master",
+        });
+    });
+
+    it("sends nothing in dry run mode", async () => {
+        const calls = stubFetch([{ body: {} }]);
+
+        await GitLab.createRelease("poznámky", "release-", true);
+
+        expect(calls).toHaveLength(0);
+    });
+});
+
+describe("findMigrationFiles", () => {
+    it("collects api migration files and ignores everything else", async () => {
+        stubFetch([
+            {
+                body: [{ new_path: "api/migrations/Version20260101120000.php" }, { new_path: "web/src/app.tsx" }],
+            },
+        ]);
+
+        await expect(GitLab.findMigrationFiles([{ id: "abc" }])).resolves.toEqual([
+            "api/migrations/Version20260101120000.php",
+        ]);
+    });
+
+    it("survives a failing commit diff instead of rejecting the whole run", async () => {
+        jest.spyOn(console, "error").mockImplementation(() => {});
+        stubFetch([{ body: { message: "nope" }, status: 500 }]);
+
+        await expect(GitLab.findMigrationFiles([{ id: "abc" }])).resolves.toEqual([]);
+    });
+});

package/src/{GoogleChat.js → google-chat.js}

@@ -1,7 +1,5 @@
 const { env } = require("process");
-const { create } = require("axios");
-
-const axios = create({});
+const { request } = require("./http");
 
 /**
  * @see https://developers.google.com/chat/api/reference/rest/v1/cards-v1
@@ -16,7 +14,7 @@ async function chatPostMessage(data, config = {}) {
 
     if (webhookUrl && !config.dryRun) {
         try {
-            await axios.post(webhookUrl, { ...data });
+            await request(webhookUrl, { method: "POST", body: { ...data } });
         } catch (error) {
             process.stderr.write("GOOGLE CHAT: chat.postMessage - error");
             console.error(error);
@@ -30,16 +28,16 @@ async function chatPostMessage(data, config = {}) {
  *
  * @param cardsV2
  * @param {{webhookUrl?: string}} config
- * @returns {Promise<axios.AxiosResponse<any>>}
+ * @returns {Promise<any>}
  */
 async function messageCardsV2(cardsV2, config = {}) {
-    return axios
-        .post(
-            config.webhookUrl ?? env.GOOGLE_WEBHOOK_URL,
-            { cardsV2 },
-            { headers: { "Content-Type": "application/json; charset=UTF-8" } },
-        )
-        .then((r) => r.data);
+    const response = await request(config.webhookUrl ?? env.GOOGLE_WEBHOOK_URL, {
+        method: "POST",
+        headers: { "Content-Type": "application/json; charset=UTF-8" },
+        body: { cardsV2 },
+    });
+
+    return response.data;
 }
 
 module.exports = {

package/src/google-chat.test.js

@@ -0,0 +1,95 @@
+const GoogleChat = require("./google-chat");
+
+const originalFetch = globalThis.fetch;
+const { GOOGLE_WEBHOOK_URL } = process.env;
+
+function stubFetch({ status = 200, payload = {} } = {}) {
+    const calls = [];
+    globalThis.fetch = async (url, init) => {
+        calls.push({ url, init });
+        return {
+            ok: status >= 200 && status < 300,
+            status,
+            headers: { get: () => "application/json" },
+            text: async () => JSON.stringify(payload),
+        };
+    };
+    return calls;
+}
+
+beforeEach(() => {
+    process.env.GOOGLE_WEBHOOK_URL = "https://chat.test/hook";
+    jest.spyOn(process.stdout, "write").mockImplementation(() => true);
+    jest.spyOn(process.stderr, "write").mockImplementation(() => true);
+    jest.spyOn(console, "error").mockImplementation(() => {});
+});
+
+afterEach(() => {
+    globalThis.fetch = originalFetch;
+    process.env.GOOGLE_WEBHOOK_URL = GOOGLE_WEBHOOK_URL;
+    jest.restoreAllMocks();
+});
+
+describe("chatPostMessage", () => {
+    it("posts the payload to the webhook from the environment", async () => {
+        const calls = stubFetch();
+
+        await GoogleChat.chatPostMessage({ text: "ahoj" });
+
+        expect(calls[0].url).toBe("https://chat.test/hook");
+        expect(calls[0].init.method).toBe("POST");
+        expect(JSON.parse(calls[0].init.body)).toEqual({ text: "ahoj" });
+    });
+
+    it("prefers an explicitly configured webhook url", async () => {
+        const calls = stubFetch();
+
+        await GoogleChat.chatPostMessage({ text: "ahoj" }, { webhookUrl: "https://other.test/hook" });
+
+        expect(calls[0].url).toBe("https://other.test/hook");
+    });
+
+    it("skips in dry run mode", async () => {
+        const calls = stubFetch();
+
+        await GoogleChat.chatPostMessage({ text: "ahoj" }, { dryRun: true });
+
+        expect(calls).toHaveLength(0);
+        expect(process.stdout.write).toHaveBeenCalledWith("GOOGLE CHAT: chat.postMessage - skipped");
+    });
+
+    it("skips when no webhook url is configured", async () => {
+        delete process.env.GOOGLE_WEBHOOK_URL;
+        const calls = stubFetch();
+
+        await GoogleChat.chatPostMessage({ text: "ahoj" });
+
+        expect(calls).toHaveLength(0);
+    });
+
+    // Notifiery posílají desítky zpráv za sebou; jedna neúspěšná nesmí shodit celý běh.
+    it("swallows a failed request instead of rejecting", async () => {
+        stubFetch({ status: 500 });
+
+        await expect(GoogleChat.chatPostMessage({ text: "ahoj" })).resolves.toBeUndefined();
+        expect(process.stderr.write).toHaveBeenCalledWith("GOOGLE CHAT: chat.postMessage - error");
+    });
+});
+
+describe("messageCardsV2", () => {
+    it("wraps the cards and sends the charset content type", async () => {
+        const calls = stubFetch();
+
+        await GoogleChat.messageCardsV2([{ cardId: "mr-1" }]);
+
+        expect(JSON.parse(calls[0].init.body)).toEqual({ cardsV2: [{ cardId: "mr-1" }] });
+        expect(calls[0].init.headers["Content-Type"]).toBe("application/json; charset=UTF-8");
+    });
+
+    // Na rozdíl od chatPostMessage tady chyba probublá — volající ji má řešit.
+    it("rejects on a failed request", async () => {
+        stubFetch({ status: 500 });
+
+        await expect(GoogleChat.messageCardsV2([])).rejects.toThrow("Request failed with status code 500");
+    });
+});