@uxf/scripts 11.21.1 → 11.23.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uxf/scripts",
-  "version": "11.21.1",
+  "version": "11.23.2",
   "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() {
@@ -143,7 +110,6 @@ function getAllProjects() {
 
 module.exports = {
     loadCommits,
-    loadIssues,
     getLastTag,
     createRelease,
     getAllMergeRequests,

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

@@ -1,99 +1,94 @@
 const GitLab = require("../GitLab");
 const Slack = require("../Slack");
 const GoogleChat = require("../GoogleChat");
+const parseCommitMessage = require("./utils/parse-commit-message");
 
-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 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);
 
-    issues.forEach(issue => {
-        message += `\n\n*${issue.title}* <${issue.web_url}|#${issue.iid}>\n${issue.commits
-            .map(generateSlackCommitMessage)
-            .join("\n")}`;
-    });
+    const issues = parsedCommit?.issues.map((issue) => `<https://youtrack.uxf.dev/issue/${issue}|${issue}>`) ?? [];
 
-    if (commitsWithoutIssues.length > 0) {
-        message += `\n\n*Commity bez issue*\n${commitsWithoutIssues.map(generateSlackCommitMessage).join("\n")}`;
+    const suffix = [`<${web_url}|${short_id}>`, author_email, issues.length > 0 ? issues.join(", ") : null]
+        .filter((i) => !!i)
+        .join(" | ");
+
+    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})`) ?? [];
+
+    const suffix = [`[${short_id}](${web_url})`, author_email, issues.length > 0 ? issues.join(", ") : null]
+        .filter((i) => !!i)
+        .join(" | ");
+
+    if (parsedCommit === null) {
+        return `- ${title} ${suffix}`;
+    }
+
+    if (parsedCommit.type !== null && parsedCommit.message !== null) {
+        return `- **${parsedCommit.type.toUpperCase()}** ${parsedCommit.message} ${suffix}`;
+    }
 
-function generateCommitMessage(commit) {
-    const { title, parsedTitle, short_id, web_url, author_email } = commit;
+    if (parsedCommit.message) {
+        return `- ${parsedCommit.message} ${suffix}`;
+    }
 
-    return parsedTitle.type
-        ? `- **${parsedTitle.type.toUpperCase()}** ${parsedTitle.subject} [${short_id}](${web_url}) (${author_email})`
-        : `- ${title} [${short_id}](${web_url}) (${author_email})`;
+    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);
 };

package/src/uxf-release/utils/parse-commit-message.js

@@ -0,0 +1,38 @@
+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[2].replace(" ", "").split(","),
+            message: result_1[3],
+        };
+    }
+
+    /* [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;
+}
+
+module.exports = parseCommitMessage;

package/src/uxf-release/utils/parse-commit-message.test.js

@@ -0,0 +1,24 @@
+const parseCommitMessage = require("./parse-commit-message");
+
+test("strings (variadic)", () => {
+    expect(parseCommitMessage("fix(bo): [KLK-1,KLK-2] message")).toEqual({
+        type: "fix",
+        issues: ["KLK-1", "KLK-2"],
+        message: "message",
+    });
+    expect(parseCommitMessage("fix(bo): [KLK-1] message")).toEqual({
+        type: "fix",
+        issues: ["KLK-1"],
+        message: "message",
+    });
+    expect(parseCommitMessage("fix: [KLK-1] message")).toEqual({
+        type: "fix",
+        issues: ["KLK-1"],
+        message: "message",
+    });
+    expect(parseCommitMessage("[KLK-1,KLK-2] message")).toEqual({
+        type: null,
+        issues: ["KLK-1", "KLK-2"],
+        message: "message",
+    });
+});