@redpanda-data/docs-extensions-and-macros 4.2.0 → 4.2.2

package/extensions/version-fetcher/fetch-latest-docker-tag.js

@@ -1,10 +1,12 @@
 /**
- * Fetches the latest version tag from Docker Hub for a given repository.
+ * Fetches the latest stable and beta version tags from Docker Hub for a given repository.
  *
+ * The function separates tags into stable (tags not including "-beta") and beta (tags including "-beta"),
+ * sorts each group by their major.minor version in descending order, and returns the top tag from each.
  *
  * @param {string} dockerNamespace - The Docker Hub namespace (organization or username)
  * @param {string} dockerRepo - The repository name on Docker Hub
- * @returns {Promise<string|null>} The latest version tag or null if none is found.
+ * @returns {Promise<{ latestStableRelease: string|null, latestBetaRelease: string|null }>}
  */
 module.exports = async (dockerNamespace, dockerRepo) => {
   const { default: fetch } = await import('node-fetch');
@@ -20,28 +22,23 @@ module.exports = async (dockerNamespace, dockerRepo) => {
 
     const data = await response.json();
 
-    // Define a regular expression to capture the major and minor version numbers.
-    // The regex /^v(\d+)\.(\d+)/ matches tags that start with "v", followed by digits (major),
-    // a period, and more digits (minor). It works for tags like "v2.3.8-24.3.6" or "v25.1-k8s4".
+    // Regex to capture major and minor version numbers (e.g. "v2.3")
     const versionRegex = /^v(\d+)\.(\d+)/;
 
-    // Filter the list of tags to include only those that match our expected version pattern.
-    // This helps ensure we work only with tags that represent valid version numbers.
-    let versionTags = data.results.filter(tag => versionRegex.test(tag.name));
+    // Filter tags to include only those matching the version pattern.
+    let tags = data.results.filter(tag => versionRegex.test(tag.name));
 
-    // If the repository is "redpanda-operator", ignore any tags starting with the old "v22 or "v23" versions.
+    // For specific repositories (e.g. "redpanda-operator"), you might want to filter out certain versions.
     if (dockerRepo === 'redpanda-operator') {
-      versionTags = versionTags.filter(tag => !/^(v22|v23)/.test(tag.name));
+      tags = tags.filter(tag => !/^(v22|v23)/.test(tag.name));
     }
 
-    if (versionTags.length === 0) {
-      console.warn('No version tags found.');
-      return null;
-    }
+    // Separate stable and beta tags.
+    const stableTags = tags.filter(tag => !tag.name.includes('-beta'));
+    const betaTags = tags.filter(tag => tag.name.includes('-beta'));
 
-    // Sort the filtered tags in descending order based on their major and minor version numbers.
-    // This sorting ignores any additional patch or suffix details and focuses only on the major.minor value.
-    versionTags.sort((a, b) => {
+    // Helper function to sort tags in descending order based on major and minor version numbers.
+    const sortTags = (a, b) => {
       const aMatch = a.name.match(versionRegex);
       const bMatch = b.name.match(versionRegex);
       const aMajor = parseInt(aMatch[1], 10);
@@ -49,18 +46,28 @@ module.exports = async (dockerNamespace, dockerRepo) => {
       const bMajor = parseInt(bMatch[1], 10);
       const bMinor = parseInt(bMatch[2], 10);
 
-      // Compare by major version first; if equal, compare by minor version.
       if (aMajor !== bMajor) {
         return bMajor - aMajor;
       }
       return bMinor - aMinor;
-    });
+    };
+
+    const sortedStable = stableTags.sort(sortTags);
+    const sortedBeta = betaTags.sort(sortTags);
+
+    const latestStableReleaseVersion = sortedStable.length ? sortedStable[0].name : null;
+    const latestBetaReleaseVersion = sortedBeta.length ? sortedBeta[0].name : null;
 
-    // Return the name of the tag with the highest major.minor version.
-    return versionTags[0].name;
+    return {
+      latestStableRelease: latestStableReleaseVersion || null,
+      latestBetaRelease: latestBetaReleaseVersion || null
+    };
 
   } catch (error) {
-    console.error('Error fetching latest Docker tag:', error);
-    return null;
+    console.error('Error fetching Docker tags:', error);
+    return {
+      latestStableRelease: null,
+      latestBetaRelease: null
+    };
   }
 };

package/extensions/version-fetcher/get-latest-redpanda-helm-version.js

@@ -1,18 +1,122 @@
+/**
+ * Fetches the latest Helm chart version from GitHub releases.
+ *
+ * This function looks for releases with tags following these patterns:
+ *   - Stable: "redpanda-5.9.21" or "25.1-k8s4" (without "beta" anywhere)
+ *   - Beta: "redpanda-5.9.21-beta", "redpanda-5.9.21-beta.1", or "25.1-k8s4-beta"
+ *
+ * It selects the highest version for each category, fetches the file at the provided path
+ * (typically Chart.yaml) using the tag as the Git ref, parses it, and returns an object with
+ * the chart version from the highest stable release and the highest beta release.
+ *
+ * @param {object} github - The GitHub API client.
+ * @param {string} owner - The repository owner.
+ * @param {string} repo - The repository name.
+ * @param {string} path - The path to the Chart.yaml file in the repository.
+ * @returns {Promise<{ latestStableRelease: string|null, latestBetaRelease: string|null }>}
+ */
 module.exports = async (github, owner, repo, path) => {
   const yaml = require('js-yaml');
   try {
-    const response = await github.repos.getContent({
-      owner: owner,
-      repo: repo,
-      path: path,
+    // Fetch up to 20 releases from GitHub.
+    const releasesResponse = await github.repos.listReleases({
+      owner,
+      repo,
+      per_page: 20,
     });
+    const releases = releasesResponse.data;
+
+    // Regex patterns:
+    // Stable regex: "redpanda-" prefix, then major.minor with an optional patch,
+    // and no "beta" anywhere in the tag.
+    const stableRegex = /^(?:redpanda-)(\d+)\.(\d+)(?:\.(\d+))?(?!.*beta)/i;
+    // Beta regex: "redpanda-" prefix, then major.minor with an optional patch,
+    // and later somewhere "beta" with an optional numeric qualifier.
+    const betaRegex = /^(?:redpanda-)(\d+)\.(\d+)(?:\.(\d+))?.*beta(?:\.(\d+))?$/i;
+
+    // Filter releases into stable and beta arrays based on tag matching.
+    const stableReleases = releases.filter(release => stableRegex.test(release.tag_name));
+    const betaReleases = releases.filter(release => betaRegex.test(release.tag_name));
+
+    // Sorting function for stable releases.
+    const sortStable = (a, b) => {
+      const aMatch = a.tag_name.match(stableRegex);
+      const bMatch = b.tag_name.match(stableRegex);
+      if (!aMatch || !bMatch) return 0;
+      const aMajor = parseInt(aMatch[1], 10);
+      const aMinor = parseInt(aMatch[2], 10);
+      const aPatch = aMatch[3] ? parseInt(aMatch[3], 10) : 0;
+      const bMajor = parseInt(bMatch[1], 10);
+      const bMinor = parseInt(bMatch[2], 10);
+      const bPatch = bMatch[3] ? parseInt(bMatch[3], 10) : 0;
+      if (aMajor !== bMajor) return bMajor - aMajor;
+      if (aMinor !== bMinor) return bMinor - aMinor;
+      return bPatch - aPatch;
+    };
+
+    // Sorting function for beta releases.
+    const sortBeta = (a, b) => {
+      const aMatch = a.tag_name.match(betaRegex);
+      const bMatch = b.tag_name.match(betaRegex);
+      if (!aMatch || !bMatch) return 0;
+      const aMajor = parseInt(aMatch[1], 10);
+      const aMinor = parseInt(aMatch[2], 10);
+      const aPatch = aMatch[3] ? parseInt(aMatch[3], 10) : 0;
+      // Optional beta number; if not provided, assume 0.
+      const aBeta = aMatch[4] ? parseInt(aMatch[4], 10) : 0;
+      const bMajor = parseInt(bMatch[1], 10);
+      const bMinor = parseInt(bMatch[2], 10);
+      const bPatch = bMatch[3] ? parseInt(bMatch[3], 10) : 0;
+      const bBeta = bMatch[4] ? parseInt(bMatch[4], 10) : 0;
+      if (aMajor !== bMajor) return bMajor - aMajor;
+      if (aMinor !== bMinor) return bMinor - aMinor;
+      if (aPatch !== bPatch) return bPatch - aPatch;
+      return bBeta - aBeta;
+    };
+
+    // Sort both arrays in descending order.
+    stableReleases.sort(sortStable);
+    betaReleases.sort(sortBeta);
+
+    // Get the highest tag from each group, if available.
+    const latestStableTag = stableReleases.length ? stableReleases[0].tag_name : null;
+    const latestBetaTag = betaReleases.length ? betaReleases[0].tag_name : null;
+
+    // Helper function to fetch and parse Chart.yaml from a given tag.
+    const fetchChartVersion = async (tag) => {
+      if (!tag) return null;
+      try {
+        const contentResponse = await github.repos.getContent({
+          owner,
+          repo,
+          path,
+          ref: tag,
+        });
+        const contentBase64 = contentResponse.data.content;
+        const contentDecoded = Buffer.from(contentBase64, 'base64').toString('utf8');
+        const chartYaml = yaml.load(contentDecoded);
+        return chartYaml.version || null;
+      } catch (error) {
+        console.error(`Failed to fetch Chart.yaml for tag ${tag}:`, error.message);
+        return null;
+      }
+    };
+
+    const [latestStableReleaseVersion, latestBetaReleaseVersion] = await Promise.all([
+      fetchChartVersion(latestStableTag),
+      fetchChartVersion(latestBetaTag)
+    ]);
+
+    return {
+      latestStableRelease: latestStableReleaseVersion,
+      latestBetaRelease: latestBetaReleaseVersion
+    };
 
-    const contentBase64 = response.data.content;
-    const contentDecoded = Buffer.from(contentBase64, 'base64').toString('utf8');
-    const chartYaml = yaml.load(contentDecoded);
-    return chartYaml.version;
   } catch (error) {
     console.error('Failed to fetch chart version:', error.message);
-    return null
+    return {
+      latestStableRelease: null,
+      latestBetaRelease: null
+    };
   }
 };

package/extensions/version-fetcher/set-latest-version.js

@@ -50,8 +50,6 @@ module.exports.register = function ({ config }) {
         connect: latestConnectResult.status === 'fulfilled' ? latestConnectResult.value : undefined,
       };
 
-      console.log(latestVersions)
-
       const components = await contentCatalog.getComponents();
       components.forEach(component => {
         const prerelease = component.latestPrerelease;
@@ -63,8 +61,8 @@ module.exports.register = function ({ config }) {
 
           // Set operator and helm chart attributes via helper function
           updateAttributes(asciidoc, [
-            { condition: latestVersions.operator, key: 'latest-operator-version', value: latestVersions.operator },
-            { condition: latestVersions.helmChart, key: 'latest-redpanda-helm-chart-version', value: latestVersions.helmChart }
+            { condition: latestVersions.operator, key: 'latest-operator-version', value: latestVersions.operator?.latestStableRelease },
+            { condition: latestVersions.helmChart, key: 'latest-redpanda-helm-chart-version', value: latestVersions.helmChart?.latestStableRelease }
           ]);
 
           // Set attributes for console and connect versions
@@ -80,9 +78,17 @@ module.exports.register = function ({ config }) {
           // Special handling for Redpanda RC versions if in beta
           if (latestVersions.redpanda?.latestRcRelease?.version) {
             setVersionAndTagAttributes(asciidoc, 'redpanda-beta', latestVersions.redpanda.latestRcRelease.version, name, version);
-            setVersionAndTagAttributes(asciidoc, 'console-beta', latestVersions.console.latestBetaRelease, name, version);
             asciidoc.attributes['redpanda-beta-commit'] = latestVersions.redpanda.latestRcRelease.commitHash;
           }
+          if (latestVersions.console?.latestBetaRelease) {
+            setVersionAndTagAttributes(asciidoc, 'console-beta', latestVersions.console.latestBetaRelease, name, version);
+          }
+          if (latestVersions.operator?.latestBetaRelease) {
+            setVersionAndTagAttributes(asciidoc, 'operator-beta', latestVersions.operator.latestBetaRelease, name, version);
+          }
+          if (latestVersions.helmChart?.latestBetaRelease) {
+            setVersionAndTagAttributes(asciidoc, 'helm-beta', latestVersions.helmChart.latestBetaRelease, name, version);
+          }
         });
 
         if (!component.latest.asciidoc) component.latest.asciidoc = { attributes: {} };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@redpanda-data/docs-extensions-and-macros",
-  "version": "4.2.0",
+  "version": "4.2.2",
   "description": "Antora extensions and macros developed for Redpanda documentation.",
   "keywords": [
     "antora",