chore: releqse script backport

Author: r0b1n

.github/workflows/PublishMarketplace.yml

@@ -3,13 +3,18 @@ name: "Publishes a package to marketplace"
 on:
     release:
         types: [published]
+    workflow_dispatch:
+        inputs:
+            package:
+                description: Package name (e.g. accordion-web)
+                required: true
 
 jobs:
     publish-new-version:
         name: "Publish a new package version from GitHub release"
         runs-on: ubuntu-latest
         env:
-            TAG: ${{ github.ref_name }}
+            TAG: ${{ github.event_name == 'release' && github.event.release.tag_name || github.event.inputs.package }}
 
         steps:
             - name: Check release tag

automation/utils/bin/rui-prepare-release.ts

@@ -2,8 +2,8 @@
 
 import assert from "node:assert/strict";
 import { getPublishedInfo, gh } from "../src";
-import { fgGreen } from "../src/ansi-colors";
 import { createDraft, publishDraft } from "../src/api/contributor";
+import chalk from "chalk";
 
 async function main(): Promise<void> {
     console.log(`Getting package information...`);
@@ -13,11 +13,11 @@ async function main(): Promise<void> {
     assert.ok(tag, "env.TAG is empty");
 
     if (marketplace.appNumber === -1) {
-        console.log(`Skipping release process for tag ${fgGreen(tag)}. appNumber is set to -1 in package.json.`);
+        console.log(`Skipping release process for tag ${chalk.green(tag)}. appNumber is set to -1 in package.json.`);
         process.exit(2);
     }
 
-    console.log(`Starting release process for tag ${fgGreen(tag)}`);
+    console.log(`Starting release process for tag ${chalk.green(tag)}`);
 
     const artifactUrl = await gh.getMPKReleaseArtifactUrl(tag);
 

automation/utils/bin/rui-publish-marketplace.ts

@@ -9,7 +9,7 @@ import {
     PublishedPackageSchema
 } from "../src";
 import { verify as verifyWidget } from "../src/verify-widget-manifest";
-import { fgCyan, fgGreen, fgYellow } from "../src/ansi-colors";
+import chalk from "chalk";
 
 async function main(): Promise<void> {
     const path = process.cwd();
@@ -51,13 +51,13 @@ async function main(): Promise<void> {
 
         // Changelog check coming soon...
 
-        console.log(fgGreen("Verification success"));
+        console.log(chalk.green("Verification success"));
     } catch (error) {
         if (error instanceof ZodError) {
             for (const issue of error.issues) {
-                const keys = issue.path.map(x => fgYellow(`${x}`));
+                const keys = issue.path.map(x => chalk.yellow(`${x}`));
                 const code = `[${issue.code}]`;
-                console.error(`package.${keys.join(".")} - ${code} ${fgCyan(issue.message)}`);
+                console.error(`package.${keys.join(".")} - ${code} ${chalk.cyan(issue.message)}`);
             }
             // Just for new line
             console.log("");

automation/utils/bin/rui-verify-package-format.ts

@@ -7,6 +7,7 @@
     "bin": {
         "rui-create-gh-release": "bin/rui-create-gh-release.ts",
         "rui-create-translation": "bin/rui-create-translation.ts",
+        "rui-prepare-release": "bin/rui-prepare-release.ts",
         "rui-publish-marketplace": "bin/rui-publish-marketplace.ts",
         "rui-update-changelog-module": "bin/rui-update-changelog-module.ts",
         "rui-update-changelog-widget": "bin/rui-update-changelog-widget.ts",
@@ -27,6 +28,7 @@
         "format": "prettier --write .",
         "lint": "eslint --ext .jsx,.js,.ts,.tsx src/",
         "prepare": "pnpm run compile:parser:widget && pnpm run compile:parser:module && tsc",
+        "prepare-release": "ts-node bin/rui-prepare-release.ts",
         "start": "tsc --watch",
         "version": "ts-node bin/rui-bump-version.ts"
     },
@@ -35,9 +37,9 @@
         "@mendix/prettier-config-web-widgets": "workspace:*",
         "@types/cross-zip": "^4.0.2",
         "@types/node-fetch": "2.6.2",
-        "chalk": "^4.1.2",
+        "chalk": "^5.4.1",
         "cross-zip": "^4.0.1",
-        "enquirer": "^2.3.6",
+        "enquirer": "^2.4.1",
         "execa": "^5.1.1",
         "fast-xml-parser": "^4.1.3",
         "node-fetch": "^2.6.9",

automation/utils/package.json

@@ -1,8 +1,8 @@
 import assert from "node:assert/strict";
-import { fetch, BodyInit } from "../fetch";
+import { BodyInit, fetch } from "../fetch";
 import { z } from "zod";
 import { Version } from "../version";
-import { fgGreen } from "../ansi-colors";
+import chalk from "chalk";
 
 export interface CreateDraftSuccessResponse {
     App: App;
@@ -115,7 +115,7 @@ export async function createDraft(params: CreateDraftParams): Promise<CreateDraf
     const { appName, appNumber, version, studioProVersion, artifactUrl, reactReady } = CreateDraftParams.parse(params);
     console.log(`Creating draft in the Mendix Marketplace...`);
     console.log(
-        fgGreen(
+        chalk.green(
             `AppName: ${appName} - AppNumber: ${appNumber} - Version: ${version.format()} - StudioPro: ${studioProVersion.format()}`
         )
     );

automation/utils/src/ansi-colors.ts

@@ -1,5 +1,5 @@
 import { join } from "node:path";
-import { fgGreen } from "./ansi-colors";
+import chalk from "chalk";
 import { getModuleInfo, getWidgetInfo, ModuleInfo, WidgetInfo } from "./package-info";
 
 export interface Output<Dirs, Files> {
@@ -65,7 +65,7 @@ export async function getWidgetBuildConfig({
     console.info(`Creating build config for ${packageName}...`);
 
     if (MX_PROJECT_PATH) {
-        console.info(fgGreen(`targetProject: using project path from MX_PROJECT_PATH.`));
+        console.info(chalk.green(`targetProject: using project path from MX_PROJECT_PATH.`));
     }
 
     const paths = {
@@ -118,7 +118,7 @@ export async function getModuleBuildConfig({
     console.info(`Creating build config for ${packageName}...`);
 
     if (MX_PROJECT_PATH) {
-        console.info(fgGreen(`targetProject: using project path from MX_PROJECT_PATH.`));
+        console.info(chalk.green(`targetProject: using project path from MX_PROJECT_PATH.`));
     }
 
     const paths = {

automation/utils/src/api/contributor.ts

@@ -136,6 +136,46 @@ export class GitHub {
 
         return filePath;
     }
+
+    private async triggerGithubWorkflow(params: {
+        workflowId: string;
+        ref: string;
+        inputs: Record<string, string>;
+        owner?: string;
+        repo?: string;
+    }): Promise<void> {
+        await this.ensureAuth();
+
+        const { workflowId, ref, inputs, owner = "mendix", repo = "web-widgets" } = params;
+
+        // Convert inputs object to CLI parameters
+        const inputParams = Object.entries(inputs)
+            .map(([key, value]) => `-f ${key}=${value}`)
+            .join(" ");
+
+        const repoParam = `${owner}/${repo}`;
+
+        const command = [`gh workflow run`, `"${workflowId}"`, `--ref "${ref}"`, inputParams, `-R "${repoParam}"`]
+            .filter(Boolean)
+            .join(" ");
+
+        try {
+            await exec(command);
+            console.log(`Successfully triggered workflow '${workflowId}'`);
+        } catch (error) {
+            throw new Error(`Failed to trigger workflow '${workflowId}': ${error}`);
+        }
+    }
+
+    async triggerCreateReleaseWorkflow(packageName: string, ref = "main"): Promise<void> {
+        return this.triggerGithubWorkflow({
+            workflowId: "CreateGitHubRelease.yml",
+            ref,
+            inputs: {
+                package: packageName
+            }
+        });
+    }
 }
 
 export const gh = new GitHub();

automation/utils/src/build-config.ts

@@ -0,0 +1,192 @@
+import nodefetch, { RequestInit } from "node-fetch";
+
+interface JiraVersion {
+    id: string;
+    name: string;
+    archived: boolean;
+    released: boolean;
+}
+
+interface JiraProject {
+    id: string;
+    key: string;
+    name: string;
+}
+
+interface JiraIssue {
+    key: string;
+    fields: {
+        summary: string;
+    };
+}
+
+export class Jira {
+    private projectKey: string;
+    private baseUrl: string;
+    private apiToken: string;
+
+    private projectId: string | undefined;
+    private projectVersions: JiraVersion[] | undefined;
+
+    constructor(projectKey: string, baseUrl: string, apiToken: string) {
+        if (!apiToken) {
+            throw new Error("API token is required.");
+        }
+        this.projectKey = projectKey;
+        this.baseUrl = baseUrl;
+
+        this.apiToken = Buffer.from(apiToken).toString("base64"); // Convert to Base64
+    }
+
+    // Private helper method for making API requests
+    private async apiRequest<T = unknown>(
+        method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH",
+        endpoint: string,
+        body?: object
+    ): Promise<T> {
+        const url = `${this.baseUrl}/rest/api/3${endpoint}`;
+        const headers = { Authorization: `Basic ${this.apiToken}` };
+
+        const httpsOptions: RequestInit = {
+            method,
+            redirect: "follow",
+            headers: {
+                Accept: "application/json",
+                ...headers,
+                ...(body && { "Content-Type": "application/json" })
+            },
+            body: body ? JSON.stringify(body) : undefined
+        };
+
+        let response;
+        try {
+            response = await nodefetch(url, httpsOptions);
+        } catch (error) {
+            throw new Error(`API request failed: ${(error as Error).message}`);
+        }
+
+        if (!response.ok) {
+            throw new Error(`API request failed (${response.status}): ${response.statusText}`);
+        }
+
+        if (response.status === 204) {
+            // No content, return empty object
+            return {} as T;
+        }
+
+        return response.json();
+    }
+
+    async initializeProjectData(): Promise<void> {
+        const projectData = await this.apiRequest<JiraProject & { versions: JiraVersion[] }>(
+            "GET",
+            `/project/${this.projectKey}`
+        );
+
+        this.projectId = projectData.id; // Save project ID
+        this.projectVersions = projectData.versions.reverse(); // Save list of versions
+    }
+
+    private versions(): JiraVersion[] {
+        if (!this.projectVersions) {
+            throw new Error("Project versions not initialized. Call initializeProjectData() first.");
+        }
+        return this.projectVersions;
+    }
+
+    getVersions(): JiraVersion[] {
+        return this.versions();
+    }
+
+    findVersion(versionName: string): JiraVersion | undefined {
+        return this.versions().find(version => version.name === versionName);
+    }
+
+    async createVersion(name: string): Promise<JiraVersion> {
+        const version = await this.apiRequest<JiraVersion>("POST", `/version`, {
+            projectId: this.projectId,
+            name
+        });
+
+        this.projectVersions!.unshift(version);
+
+        return version;
+    }
+
+    async assignVersionToIssue(versionId: string, issueKey: string): Promise<void> {
+        const currentVersions = await this.getFixVersionsForIssue(issueKey);
+        if (currentVersions.some(version => version.id === versionId)) {
+            // Version already exists
+            return;
+        }
+
+        const updatedVersions = [...currentVersions.map(version => ({ id: version.id })), { id: versionId }];
+
+        await this.apiRequest("PUT", `/issue/${issueKey}`, {
+            fields: {
+                fixVersions: updatedVersions
+            }
+        });
+    }
+
+    async deleteVersion(versionId: string): Promise<void> {
+        await this.apiRequest("DELETE", `/version/${versionId}`);
+
+        // Remove the version from the cached project versions
+        this.projectVersions = this.projectVersions?.filter(version => version.id !== versionId);
+    }
+
+    async getFixVersionsForIssue(issueKey: string): Promise<JiraVersion[]> {
+        const issue = await this.apiRequest<{ fields: { fixVersions: JiraVersion[] } }>(
+            "GET",
+            `/issue/${issueKey}?fields=fixVersions`
+        );
+
+        return issue.fields.fixVersions || [];
+    }
+
+    async removeFixVersionFromIssue(versionId: string, issueKey: string): Promise<void> {
+        // First, get current fix versions
+        const currentVersions = await this.getFixVersionsForIssue(issueKey);
+
+        // Filter out the version to remove
+        const updatedVersions = currentVersions
+            .filter(version => version.id !== versionId)
+            .map(version => ({ id: version.id }));
+
+        // Update the issue with the filtered versions
+        await this.apiRequest("PUT", `/issue/${issueKey}`, {
+            fields: {
+                fixVersions: updatedVersions
+            }
+        });
+    }
+
+    private async getIssuesForVersion(versionId: string): Promise<string[]> {
+        const issues = await this.apiRequest<{ issues: Array<{ key: string }> }>(
+            "GET",
+            `/search?jql=fixVersion=${versionId}`
+        );
+
+        return issues.issues.map(issue => issue.key);
+    }
+
+    async getIssuesWithDetailsForVersion(versionId: string): Promise<JiraIssue[]> {
+        const response = await this.apiRequest<{ issues: JiraIssue[] }>(
+            "GET",
+            `/search?jql=fixVersion=${versionId}&fields=summary`
+        );
+
+        return response.issues;
+    }
+
+    async searchIssueByKey(issueKey: string): Promise<JiraIssue | null> {
+        try {
+            const issue = await this.apiRequest<JiraIssue>("GET", `/issue/${issueKey}?fields=summary`);
+            return issue;
+        } catch (_e) {
+            // If issue not found or other error
+            return null;
+        }
+    }
+}