@uxf/scripts 11.14.0 → 11.23.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uxf/scripts",
-  "version": "11.14.0",
+  "version": "11.23.1",
   "description": "",
   "main": "index.js",
   "bin": {
@@ -26,7 +26,6 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@commitlint/parse": "19.0.3",
     "axios": "1.6.7",
     "cheerio": "1.0.0-rc.12",
     "dayjs": "1.11.10",

package/src/GitLab.js

@@ -1,7 +1,6 @@
 const { env } = require("process");
 const { create } = require("axios");
 const dayjs = require("dayjs");
-const parse = import("@commitlint/parse");
 
 const axios = create({
     baseURL: `${env.CI_SERVER_URL}/api/v4`,
@@ -36,7 +35,6 @@ async function getAll(url, config) {
 
 async function loadCommits(from) {
     const commits = [];
-    console.log(`- start date: ${from}`);
 
     let nextPage = "1";
     do {
@@ -52,38 +50,7 @@ async function loadCommits(from) {
         commits.push(...response.data);
     } while (nextPage);
 
-    const preparedCommits = [];
-    for (const commit of commits) {
-        if (commit.created_at === from) {
-            continue;
-        }
-
-        const parsedTitle = await parse(commit.title, undefined, { issuePrefixes: ["#"] });
-
-        preparedCommits.push({
-            ...commit,
-            parsedTitle: {
-                scope: parsedTitle.scope,
-                type: parsedTitle.type,
-                subject: (parsedTitle.subject || commit.title).replace(/(#[0-9]*)/g, "").trim(),
-            },
-            issueIds: parsedTitle.references.map((ref) => Number.parseInt(ref.issue)).filter((i) => !!i),
-        });
-    }
-
-    return preparedCommits;
-}
-
-async function loadIssues(iids) {
-    if (iids.length === 0) {
-        return [];
-    }
-
-    const { data } = await axios.get(`/projects/${env.CI_PROJECT_ID}/issues`, {
-        params: { iids },
-    });
-
-    return data;
+    return commits.filter((commit) => commit.created_at !== from);
 }
 
 async function getLastTag() {
@@ -121,11 +88,14 @@ function getSingleMergeRequestChanges(projectId, mr_iid) {
     return axios.get(`/projects/${projectId}/merge_requests/${mr_iid}/changes`).then((r) => r.data);
 }
 
-function getAllMergeRequests() {
+/**
+ * @param {boolean} includeWip
+ */
+function getAllMergeRequests(includeWip) {
     return getAll("/merge_requests", {
         params: {
             approwed: "no",
-            wip: "no",
+            wip: includeWip ? undefined : "no",
             sort: "asc",
             scope: "all",
             state: "opened",
@@ -140,7 +110,6 @@ function getAllProjects() {
 
 module.exports = {
     loadCommits,
-    loadIssues,
     getLastTag,
     createRelease,
     getAllMergeRequests,

package/src/uxf-merge-requests-notifier/cli.js

@@ -1,12 +1,15 @@
 const { argv, env } = require("process");
 
+const AVAILABLE_VARIANTS = ["CR", "STALE"];
+
 module.exports = async () => {
     const cli = require("yargs")
         .command("$0", "UXF merge requests notifier", (yargs) => {
             yargs.demandCommand(0, 0).usage(`Usage:
   uxf-merge-requests-notifier [options]
-  
+
 Environment variables:
+  VARIANT            - optional - CR (default), STALE
   GITLAB_TOKEN       - required
   GOOGLE_WEBHOOK_URL - required
   CI_SERVER_URL      - required - setting by GitLab CI`);
@@ -32,7 +35,14 @@ Environment variables:
             return 1;
         }
 
-        await require("./index")();
+        const variant = env.VARIANT?.toUpperCase() ?? "CR";
+
+        if (!AVAILABLE_VARIANTS.includes(variant)) {
+            console.log(`Unknown "${variant}" variant. Available variants are ${AVAILABLE_VARIANTS.join(", ")}.`);
+            return 1;
+        }
+
+        await require("./index")(variant);
     } catch (e) {
         console.error(e);
         return 1;

package/src/uxf-merge-requests-notifier/index.js

@@ -10,41 +10,59 @@ function inflect(value, word1, word2, word3) {
     return `${value} ${value === 1 ? word1 : value <= 4 ? word2 : word3}`;
 }
 
-module.exports = async function run() {
+function mapMergeRequests(mrs, projects) {
+    return mrs.map((mr) => ({
+        id: mr.id,
+        iid: mr.iid,
+        reviewers: mr.reviewers ?? [],
+        project: projects.find((project) => project.id === mr.project_id),
+        title: mr.title,
+        author: mr.author,
+        createdAt: mr.created_at,
+        updatedAt: mr.updated_at,
+        webUrl: mr.web_url,
+        state: mr.state.toUpperCase(),
+        targetBranch: mr.target_branch,
+        sourceBranch: mr.source_branch,
+    }));
+}
+
+function getChatPostMessage(resultsCount, variant) {
+    switch (variant) {
+        case "CR":
+            return `🔥🔥🔥 ${inflect(resultsCount, "MR čekající na code review", "MR čekající na code review", "MR čekajících na code review",)}`;
+        case "STALE":
+            return `❗❗❗ ${inflect(resultsCount, "MR starší než měsíc", "MR starší než měsíc", "MR starších než měsíc")}`;
+    }
+}
+
+/**
+ * @param variant
+ */
+module.exports = async function run(variant) {
     const projects = await GitLab.getAllProjects();
-    const allMergeRequests = await GitLab.getAllMergeRequests();
+    const allMergeRequests = await GitLab.getAllMergeRequests(variant === "STALE");
 
-    const result = allMergeRequests
-        .map((mr) => ({
-            id: mr.id,
-            iid: mr.iid,
-            reviewers: mr.reviewers ?? [],
-            project: projects.find((project) => project.id === mr.project_id),
-            title: mr.title,
-            author: mr.author,
-            createdAt: mr.created_at,
-            updatedAt: mr.updated_at,
-            webUrl: mr.web_url,
-            state: mr.state.toUpperCase(),
-            targetBranch: mr.target_branch,
-            sourceBranch: mr.source_branch,
-        }))
-        .filter((mr) => mr.reviewers.length === 0)
+    let result = mapMergeRequests(allMergeRequests, projects)
         .filter((mr) => mr.sourceBranch !== "develop" || mr.targetBranch !== "master")
         .filter((mr) => !mr.project.archived);
 
+    switch (variant) {
+        case "CR":
+            result = result.filter((mr) => mr.reviewers.length === 0);
+            break;
+        case "STALE":
+            result = result.filter(mr => dayjs().diff(mr.updatedAt, "days") > 30);
+            break;
+    }
+
     if (result.length === 0) {
-        console.log("No merge requests to code review.");
+        console.log("No merge requests.");
         return;
     }
 
     await GoogleChat.chatPostMessage({
-        text: `🔥🔥🔥 ${inflect(
-            result.length,
-            "MR čekající na code review",
-            "MR čekající na code review",
-            "MR čekajících na code review",
-        )}`,
+        text: getChatPostMessage(result.length, variant),
     });
 
     for (const mr of result) {

package/src/uxf-release/cli.js

@@ -2,16 +2,17 @@ const { argv, env } = require("process");
 
 module.exports = async () => {
     const cli = require("yargs")
-        .command("$0", "UXF release helper", yargs => {
+        .command("$0", "UXF release helper", (yargs) => {
             yargs.demandCommand(0, 0).usage(`UXF release helper
 Usage:
   uxf-release [options]
   
 Environment variables:
-  GITLAB_TOKEN      - required
-  CI_SERVER_URL     - required - setting by GitLab CI
-  CI_PROJECT_ID     - required - setting by GitLab CI
-  SLACK_TOKEN       - optional`);
+  GITLAB_TOKEN        - required
+  CI_SERVER_URL       - required - setting by GitLab CI
+  CI_PROJECT_ID       - required - setting by GitLab CI
+  SLACK_TOKEN         - optional
+  GOOGLE_WEBHOOK_URL  - optional`);
         })
         .option("m", {
             alias: "message",
@@ -55,11 +56,6 @@ Environment variables:
             env.CI_PROJECT_ID = projectId;
         }
 
-        if (!slackChannel) {
-            console.log("Slack channel must be set. Use parameter -s or --slack-channel");
-            return 1;
-        }
-
         if (!env.CI_SERVER_URL) {
             console.log("GitLab url must be set. Use environment variable CI_SERVER_URL.");
             return 1;

package/src/uxf-release/index.js

@@ -2,98 +2,129 @@ const GitLab = require("../GitLab");
 const Slack = require("../Slack");
 const GoogleChat = require("../GoogleChat");
 
-function addCommitsToIssues(commits, issues) {
-    issues.forEach(issue => {
-        if (issue.commits === undefined) {
-            issue.commits = [];
-        }
-    });
-
-    commits.forEach(commit => {
-        if (commit.issueIds.length > 0) {
-            issues.forEach(issue => {
-                if (commit.issueIds.includes(issue.iid)) {
-                    issue.commits.push(commit);
-                }
-            });
-        }
-    });
+function parseCommitMessage(commitMessage) {
+    /* fix(bo): [KLK-123] commit message */
+    const result = /^(.*)\((.*)\): \[(.*)\] (.*)/.exec(commitMessage);
+
+    if (result !== null) {
+        return {
+            type: result[1],
+            issues: result[3].replace(" ", "").split(","),
+            message: result[4],
+        };
+    }
+
+    /* fix: [KLK-123] commit message */
+    const result_1 = /^(.*): \[(.*)\] (.*)/.exec(commitMessage);
+
+    if (result_1 !== null) {
+        return {
+            type: result_1[1],
+            issues: result_1[3].replace(" ", "").split(","),
+            message: result_1[4],
+        };
+    }
+
+    /* [KLK-123] commit message */
+    const result_2 = /^\[(.*)\] (.*)/.exec(commitMessage);
+
+    if (result_2 !== null) {
+        return {
+            type: null,
+            issues: result_2[1].replace(" ", "").split(","),
+            message: result_2[2],
+        };
+    }
+
+    return null;
+}
+
+function generateSlackCommitMessage(commit) {
+    const { title, short_id, web_url, author_email } = commit;
+
+    const parsedCommit = parseCommitMessage(title);
+
+    return parsedCommit?.type
+        ? `• _${parsedCommit.type.toUpperCase()}_ - ${parsedCommit.message} <${web_url}|${short_id}> (${author_email})`
+        : `• ${title} <${web_url}|${short_id}> (${author_email})`;
 }
 
-function getIssueIdsFromCommits(commits) {
-    const ids = [];
-    commits.forEach(c => ids.push(...c.issueIds));
-    return ids.filter((v, i, s) => s.indexOf(v) === i);
+function generateSlackMessage(commits, messageTitle) {
+    return {
+        text: `${messageTitle}
+
+${commits.map(generateSlackCommitMessage).join("\n")}
+`,
+    };
 }
 
-function generateSlackMessage(issues, commitsWithoutIssues, messageTitle) {
-    let message = messageTitle;
+function generateGoogleCommitMessage(commit) {
+    const { title, short_id, web_url, author_email } = commit;
+    const parsedCommit = parseCommitMessage(title);
+
+    const issues = parsedCommit?.issues.map((issue) => `<https://youtrack.uxf.dev/issue/${issue}|${issue}>`) ?? [];
 
-    issues.forEach(issue => {
-        message += `\n\n*${issue.title}* <${issue.web_url}|#${issue.iid}>\n${issue.commits
-            .map(generateSlackCommitMessage)
-            .join("\n")}`;
-    });
+    const suffix = [`<${web_url}|${short_id}>`, author_email, issues.length > 0 ? issues.join(", ") : null]
+        .filter((i) => !!i)
+        .join(" | ");
 
-    if (commitsWithoutIssues.length > 0) {
-        message += `\n\n*Commity bez issue*\n${commitsWithoutIssues.map(generateSlackCommitMessage).join("\n")}`;
+    if (parsedCommit === null) {
+        return `* ${title} ${suffix}`;
     }
 
-    return message;
-}
+    if (parsedCommit.type !== null && parsedCommit.message !== null) {
+        return `* _${parsedCommit.type.toUpperCase()}_ ${parsedCommit.message} ${suffix}`;
+    }
 
-function generateGoogleMessage(issues, commitsWithoutIssues, messageTitle) {
-    const texts = [messageTitle];
-    issues.forEach(issue => {
-        texts.push(`*${issue.title}* <${issue.web_url}|#${issue.iid}>`);
-        issue.commits.forEach((commit) => texts.push(generateSlackCommitMessage(commit)));
-    });
-    if (commitsWithoutIssues.length > 0) {
-        texts.push(`*Commity bez issue*`);
-        commitsWithoutIssues.forEach((commit) => texts.push(generateSlackCommitMessage(commit)));
+    if (parsedCommit.message) {
+        return `* ${parsedCommit.message} ${suffix}`;
     }
+
+    return `* ${title} ${suffix}`;
+}
+
+function generateGoogleMessage(commits, messageTitle) {
     return {
-        text: texts.join('\n')
+        text: `${messageTitle}
+        
+${commits.map(generateGoogleCommitMessage).join("\n")}
+`,
     };
 }
 
-function generateSlackCommitMessage(commit) {
-    const { title, parsedTitle, short_id, web_url, author_email } = commit;
+function generateReleaseCommitMessage(commit) {
+    const { title, short_id, web_url, author_email } = commit;
 
-    return parsedTitle.type
-        ? `• _${parsedTitle.type.toUpperCase()}_ ${parsedTitle.scope} - ${
-              parsedTitle.subject
-          } <${web_url}|${short_id}> (${author_email})`
-        : `• ${title} <${web_url}|${short_id}> (${author_email})`;
-}
+    const parsedCommit = parseCommitMessage(title);
+
+    const issues = parsedCommit?.issues.map((issue) => `[${issue}](https://youtrack.uxf.dev/issue/${issue})`) ?? [];
 
-function generateCommitMessage(commit) {
-    const { title, parsedTitle, short_id, web_url, author_email } = commit;
+    const suffix = [`[${short_id}](${web_url})`, author_email, issues.length > 0 ? issues.join(", ") : null]
+        .filter((i) => !!i)
+        .join(" | ");
 
-    return parsedTitle.type
-        ? `- **${parsedTitle.type.toUpperCase()}** ${parsedTitle.subject} [${short_id}](${web_url}) (${author_email})`
-        : `- ${title} [${short_id}](${web_url}) (${author_email})`;
+    if (parsedCommit === null) {
+        return `- ${title} ${suffix}`;
+    }
+
+    if (parsedCommit.type !== null && parsedCommit.message !== null) {
+        return `- **${parsedCommit.type.toUpperCase()}** ${parsedCommit.message} ${suffix}`;
+    }
+
+    if (parsedCommit.message) {
+        return `- ${parsedCommit.message} ${suffix}`;
+    }
+
+    return `- ${title} ${suffix}`;
 }
 
 module.exports = async (dryRun, channel, messageTitle) => {
     const lastTag = await GitLab.getLastTag();
     const commits = await GitLab.loadCommits(lastTag ? lastTag.commit.committed_date : null);
-    const issues = await GitLab.loadIssues(getIssueIdsFromCommits(commits));
-
-    addCommitsToIssues(commits, issues);
-
-    const commitsWithoutIssue = commits.filter(c => c.issueIds.length === 0);
 
-    await Slack.chatPostMessage(
-        channel,
-        { text: generateSlackMessage(issues, commitsWithoutIssue, messageTitle) },
-        dryRun,
-    );
+    await Slack.chatPostMessage(channel, { text: generateSlackMessage(commits, messageTitle) }, dryRun);
 
-    await GoogleChat.chatPostMessage(
-        generateGoogleMessage(issues, commitsWithoutIssue, messageTitle),
-        dryRun,
-    );
+    await GoogleChat.chatPostMessage(generateGoogleMessage(commits, messageTitle), dryRun);
 
-    await GitLab.createRelease(commits.map(generateCommitMessage).join("\n"), dryRun);
+    await GitLab.createRelease(commits.map(generateReleaseCommitMessage).join("\n"), dryRun);
 };