Merge pull request #125 from morri-son/enhance-controller-release

Enhance controller release

Author: morri-son

.github/scripts/prepare-registry-constructor.js

@@ -1,7 +1,7 @@
 // @ts-check
 import fs from 'fs';
 import yaml from 'js-yaml';
-import {computeNextVersions} from "./compute-rc-version.js";
+import {computeNextVersions} from "./release-versioning.js";
 import {execSync} from "child_process";
 import {dirname} from "path";
 

.github/scripts/compute-rc-version.js .github/scripts/release-versioning.js.github/scripts/compute-rc-version.js renamed to .github/scripts/release-versioning.js

@@ -1,5 +1,5 @@
 // @ts-check
-import { execSync } from "child_process";
+import { execFileSync } from "child_process";
 
 // --------------------------
 // GitHub Actions entrypoint
@@ -17,8 +17,25 @@ export default async function computeRcVersion({ core }) {
     const basePrefix = parseBranch(releaseBranch);
     const tagPrefix = `${componentPath}/v`;
 
-    const latestStable = run(core, `git tag --list '${tagPrefix}${basePrefix}.*' | sort -V | tail -n1`);
-    const latestRc = run(core, `git tag --list '${tagPrefix}${basePrefix}.*-rc.*' | sort -V | tail -n1`);
+    // Get latest stable tag using Git's native version sort (descending)
+    // Filter out RC tags after fetching since git doesn't support negative pattern matching
+    const stableTags = run(core, "git", [
+        "tag", "--list", `${tagPrefix}${basePrefix}.*`,
+        "--sort=-version:refname"
+    ]);
+    const latestStable = stableTags
+        .split("\n")
+        .filter(tag => tag && !/-rc\.\d+$/.test(tag))[0] || "";
+
+    // Get latest RC tag using Git's native version sort (descending)
+    const rcTags = run(core, "git", [
+        "tag", "--list", `${tagPrefix}${basePrefix}.*-rc.*`,
+        "--sort=-version:refname"
+    ]);
+    const latestRc = rcTags.split("\n").filter(Boolean)[0] || "";
+
+    core.info(`Latest stable: ${latestStable || "(none)"}`);
+    core.info(`Latest RC: ${latestRc || "(none)"}`);
 
     const { baseVersion, rcVersion } = computeNextVersions(basePrefix, latestStable, latestRc, false);
 
@@ -56,14 +73,22 @@ export default async function computeRcVersion({ core }) {
 // --------------------------
 // Core helpers
 // --------------------------
-export function run(core, cmd) {
-  core.info(`> ${cmd}`);
+/**
+ * Run a shell command safely using execFileSync.
+ * @param {*} core - GitHub Actions core module
+ * @param {string} executable - The executable to run (e.g., "git", "grep")
+ * @param {string[]} args - Array of arguments
+ * @returns {string} Command output or empty string on failure
+ */
+export function run(core, executable, args) {
+  const cmdStr = `${executable} ${args.join(" ")}`;
+  core.info(`> ${cmdStr}`);
   try {
-    const out = execSync(cmd).toString().trim();
+    const out = execFileSync(executable, args, { encoding: "utf-8" }).trim();
     if (out) core.info(`Output: ${out}`);
     return out;
   } catch (err) {
-    core.warning(`Command failed: ${cmd}\n${err.message}`);
+    core.warning(`Command failed: ${cmdStr}\n${err.message}`);
     return "";
   }
 }
@@ -166,7 +191,7 @@ export function isStableNewer(stable, rc) {
     const stableParts = parseVersion(stable);
     const rcParts = parseVersion(rc);
 
-    // Compare [major, minor, patch] lexicographically
+    // Compare [major, minor, patch] numerically
     for (let i = 0; i < 3; i++) {
         const s = stableParts[i] || 0;
         const r = rcParts[i] || 0;
@@ -190,3 +215,45 @@ export function parseVersion(tag) {
     const version = tag.replace(/^.*v/, "").replace(/-rc\.\d+$/, "");
     return version.split(".").map(Number);
 }
+
+// --------------------------
+// Latest release determination
+// --------------------------
+
+/** GitHub Actions entrypoint for determining if release should be latest */
+export async function determineLatestRelease({ core, github, context }) {
+    const { COMPONENT_PATH: componentPath, PROMOTION_VERSION: promotionVersion } = process.env;
+    if (!componentPath || !promotionVersion) return core.setFailed("Missing COMPONENT_PATH or PROMOTION_VERSION");
+
+    const tagPrefix = `${componentPath}/v`;
+    let releases = [];
+    try {
+        releases = (await github.rest.repos.listReleases({ owner: context.repo.owner, repo: context.repo.repo, per_page: 100 })).data;
+    } catch (e) {
+        core.setFailed(`Could not fetch releases: ${e.message}`);
+        return;
+    }
+
+    const highestFinal = extractHighestFinalVersion(releases, tagPrefix);
+    const setLatest = shouldSetLatest(promotionVersion, highestFinal);
+
+    core.setOutput('set_latest', setLatest ? 'true' : 'false');
+    core.setOutput('highest_final_version', highestFinal || '(none)');
+    core.info(setLatest ? `✅ Will set :latest (${promotionVersion} >= ${highestFinal || 'none'})` : `⚠️ Will NOT set :latest (${promotionVersion} < ${highestFinal})`);
+
+    await core.summary.addRaw('---').addEOL().addHeading('Latest Tag Decision', 2)
+        .addTable([[{ data: 'Field', header: true }, { data: 'Value', header: true }], ['Final Version', promotionVersion], ['Highest Final Version', highestFinal || '(none)'], ['Will Set Latest', setLatest ? '✅ Yes' : '⚠️ No']]).write();
+}
+
+/** Extract highest final (non-prerelease) version from releases */
+export function extractHighestFinalVersion(releases, tagPrefix) {
+    const versions = releases.filter(r => !r.prerelease && r.tag_name.startsWith(tagPrefix))
+        .map(r => r.tag_name.replace(tagPrefix, '')).filter(v => /^\d+\.\d+\.\d+$/.test(v));
+    if (!versions.length) return '';
+    return versions.sort((a, b) => isStableNewer(`v${a}`, `v${b}`) ? 1 : -1).pop();
+}
+
+/** Determine if promotion version should be tagged as latest */
+export function shouldSetLatest(promotionVersion, highestFinal) {
+    return !highestFinal || !isStableNewer(`v${highestFinal}`, `v${promotionVersion}`);
+}

…ithub/scripts/compute-rc-version.test.js …ithub/scripts/release-versioning.test.js.github/scripts/compute-rc-version.test.js renamed to .github/scripts/release-versioning.test.js .github/scripts/compute-rc-version.test.js renamed to .github/scripts/release-versioning.test.js

@@ -1,5 +1,12 @@
 import assert from "assert";
-import { computeNextVersions, isStableNewer, parseBranch, parseVersion } from "./compute-rc-version.js";
+import {
+    computeNextVersions,
+    isStableNewer,
+    parseBranch,
+    parseVersion,
+    extractHighestFinalVersion,
+    shouldSetLatest,
+} from "./release-versioning.js";
 
 // ----------------------------------------------------------
 // parseVersion tests
@@ -31,12 +38,19 @@ assert.deepStrictEqual(v1, {
     rcVersion: "0.1.1-rc.1",
 }, "RC version should be bumped when starting from a stable version");
 
-// 2. New RC from existing RC (RC increments)
+// 2. Stable + RC on same base => start next minor RC line
 const v2 = computeNextVersions("0.1", "cli/v0.1.1", "cli/v0.1.1-rc.4", false);
 assert.deepStrictEqual(v2, {
     baseVersion: "0.1.2",
     rcVersion: "0.1.2-rc.1",
-}, "RC version should be incremented when starting from an existing RC");
+}, "When stable exists for the same base as latest RC, start next minor RC line");
+
+// 2b. No stable yet for current line + existing RC => continue same RC line
+const v2b = computeNextVersions("0.4", "", "cli/v0.4.0-rc.3", false);
+assert.deepStrictEqual(v2b, {
+    baseVersion: "0.4.0",
+    rcVersion: "0.4.0-rc.4",
+}, "Without a stable tag, RC line must continue on the same base");
 
 // 3. Same base between stable and RC with minor version bump
 const v3 = computeNextVersions("0.1", "cli/v0.1.0", "cli/v0.1.0-rc.4", true);
@@ -112,4 +126,68 @@ assert.ok(
     "Should return false if no stable tag"
 );
 
-console.log("✅ All tests passed.");
+// ----------------------------------------------------------
+// extractHighestFinalVersion tests
+// ----------------------------------------------------------
+const mockReleases = [
+    { prerelease: false, tag_name: "cli/v0.1.0" },
+    { prerelease: true, tag_name: "cli/v0.1.1-rc.1" },
+    { prerelease: false, tag_name: "cli/v0.1.2" },
+    { prerelease: false, tag_name: "cli/v0.2.0" },
+    { prerelease: false, tag_name: "other/v1.0.0" },
+    { prerelease: true, tag_name: "cli/v0.3.0-rc.1" },
+];
+
+assert.strictEqual(
+    extractHighestFinalVersion(mockReleases, "cli/v"),
+    "0.2.0",
+    "Should return highest non-prerelease version for prefix"
+);
+
+assert.strictEqual(
+    extractHighestFinalVersion(mockReleases, "other/v"),
+    "1.0.0",
+    "Should filter by tag prefix"
+);
+
+assert.strictEqual(
+    extractHighestFinalVersion([], "cli/v"),
+    "",
+    "Should return empty string for no releases"
+);
+
+assert.strictEqual(
+    extractHighestFinalVersion([{ prerelease: true, tag_name: "cli/v0.1.0-rc.1" }], "cli/v"),
+    "",
+    "Should return empty string if only prereleases exist"
+);
+
+// ----------------------------------------------------------
+// shouldSetLatest tests
+// ----------------------------------------------------------
+assert.ok(
+    shouldSetLatest("0.2.0", ""),
+    "Should return true if no existing final version"
+);
+
+assert.ok(
+    shouldSetLatest("0.2.0", "0.1.0"),
+    "Should return true if promotion > highest"
+);
+
+assert.ok(
+    shouldSetLatest("0.2.0", "0.2.0"),
+    "Should return true if promotion == highest"
+);
+
+assert.ok(
+    !shouldSetLatest("0.1.0", "0.2.0"),
+    "Should return false if promotion < highest"
+);
+
+assert.ok(
+    shouldSetLatest("0.10.0", "0.9.0"),
+    "Should handle numeric comparison correctly (0.10 > 0.9)"
+);
+
+console.log("✅ All tests passed.");