@redpanda-data/docs-extensions-and-macros 3.1.4 → 3.2.0

package/README.adoc

@@ -79,9 +79,11 @@ antora:
 
 === Version fetcher
 
-This extension fetches the latest release tag and latest release commit hash from http://github.com/redpanda-data/redpanda. These values are then assigned to the `full-version` and `latest-release-commit` attributes of the latest version of the Redpanda documentation, respectively.
+This extension fetches the latest release versions from GitHub.
 
-It also fetches the latest version of Redpanda Console and assigns it to the `latest-console-version` attribute in the playbook so that all components have access to it.
+The latest Console version is made available to all versions of the Redpanda docs (`ROOT` component.)
+
+The latest Redpanda version and the latest Redpanda Operator version is made available to the latest version of the `ROOT` component.
 
 ==== Environment variables
 
@@ -97,6 +99,75 @@ antora:
   - '@redpanda-data/docs-extensions-and-macros/extensions/version-fetcher/set-latest-version'
 ```
 
+=== Validate attributes
+
+This extension ensures the consistency and validity of page attributes, focusing on validating page categories against a predefined list of valid categories and subcategories. It automatically adds missing parent categories for any specified subcategories and removes any specified categories that are invalid. Additionally, it processes specific environment attributes, setting corresponding page-level attributes when environment conditions are met.
+
+==== Environment variables
+
+This extension does not require any environment variables.
+
+==== Configuration options
+
+There are no configurable options for this extension. It operates based on site attributes defined in `add-global-attributes.js` to determine valid categories and subcategories.
+
+==== Registration example
+
+Register the `validate-attributes` extension in the Antora playbook under the `antora.extensions` key like so:
+
+[source,yaml]
+----
+antora:
+  extensions:
+    - require: '@redpanda-data/docs-extensions-and-macros/extensions/validate-attributes.js'
+----
+
+=== Related docs
+
+This extension enhances the connectivity between lab exercises and relevant documentation by dynamically identifying and linking related documentation pages and other lab exercises based on shared categories and deployment types.
+
+==== Environment variables
+
+This extension operates without requiring any specific environment variables.
+
+==== Configuration options
+
+This extension does not offer configurable options. It uses the inherent attributes of pages to determine relationships based on `page-categories` and deployment types (`env-kubernetes`, `env-linux`, `env-docker`, `page-cloud`).
+
+==== Registration example
+
+To integrate the `related-docs-extension` into your Antora playbook, add it under the `antora.extensions` key as demonstrated below:
+
+[source,yaml]
+----
+antora:
+  extensions:
+    - require: '@redpanda-data/docs-extensions-and-macros/extensions/related-docs-extension.js'
+----
+
+=== Related labs
+
+This extension enriches documentation pages with links to related lab exercises, facilitating a deeper understanding of the content through practical application. It dynamically assigns related labs to each documentation page based on shared categories and deployment types.
+
+==== Environment variables
+
+This extension does not require any environment variables.
+
+==== Configuration options
+
+The extension operates without explicit configuration options. It automatically processes documentation pages to identify and link related labs based on shared `page-categories` attributes and deployment types (`env-kubernetes`, `env-linux`, `env-docker`, `page-cloud`).
+
+==== Registration example
+
+Include the `related-labs-extension` in the Antora playbook under the `antora.extensions` key as follows:
+
+[source,yaml]
+----
+antora:
+  extensions:
+    - require: '@redpanda-data/docs-extensions-and-macros/extensions/related-labs-extension.js'
+----
+
 === Global attributes
 
 This extension collects Asciidoc attributes from the {url-playbook}[`shared` component] and makes them available to all component versions. Having global attributes is useful for consistent configuration of local and production builds.

package/extensions/add-global-attributes.js

@@ -11,31 +11,31 @@ module.exports.register = function ({ config }) {
   const _ = require('lodash');
 
   this.on('contentAggregated', ({ siteCatalog, contentAggregate }) => {
-    let attributeFile;
     try {
       for (const component of contentAggregate) {
         if (component.name === 'shared') {
-          attributeFile = component.files.find(file => file.path.includes('attributes.yml'));
-          if (!attributeFile) {
-            logger.warn("No attributes.yml file found in 'shared' component.");
+          const attributeFiles = component.files.filter(file => file.path.startsWith('modules/ROOT/partials/') && file.path.endsWith('.yml'));
+          if (!attributeFiles.length) {
+            logger.warn("No YAML attributes files found in 'shared' component.");
           } else {
-            siteCatalog.attributeFile = yaml.load(attributeFile.contents.toString('utf8'));
-            console.log(chalk.green('Loaded attributes from shared component.'));
+            siteCatalog.attributeFile = attributeFiles.reduce((acc, file) => {
+              const fileAttributes = yaml.load(file.contents.toString('utf8'));
+              return _.merge(acc, fileAttributes);
+            }, {});
+            console.log(chalk.green('Loaded global attributes from shared component.'));
           }
-          break
+          break;
         }
       }
     } catch (error) {
       logger.error(`Error loading attributes: ${error.message}`);
     }
   })
-  .on('contentClassified', async ({ siteCatalog,contentCatalog }) => {
+  .on('contentClassified', async ({ siteCatalog, contentCatalog }) => {
     const components = await contentCatalog.getComponents();
     for (let i = 0; i < components.length; i++) {
       let component = components[i];
-      if (component.name !== 'ROOT' && component.name !== 'preview') continue
-
-      component.versions.forEach(({asciidoc}) => {
+      component.versions.forEach(({ asciidoc }) => {
         if (siteCatalog.attributeFile) {
           asciidoc.attributes = _.merge({}, siteCatalog.attributeFile, asciidoc.attributes);
         }

package/extensions/algolia-indexer/generate-index.js

@@ -27,7 +27,6 @@ function generateIndex (playbook, contentCatalog, { indexLatestOnly = false, exc
   const algolia = {}
 
   console.log(chalk.cyan('Indexing...'))
-
   const unixTimestamp = Math.floor(Date.now() / 1000)
 
   // Select indexable pages
@@ -176,27 +175,39 @@ function generateIndex (playbook, contentCatalog, { indexLatestOnly = false, exc
       .replace(/\s+/g, ' ')
       .trim();
 
-    var tag = `${component.title}-${version}`
+    var tag = `${component.title}${version ? '-' + version : ''}`
+    var indexItem;
+    const deployment = page.asciidoc?.attributes['env-kubernetes'] ? 'Kubernetes' : page.asciidoc?.attributes['env-linux'] ? 'Linux' : page.asciidoc?.attributes['env-docker'] ? 'Docker' : page.asciidoc?.attributes['page-cloud'] ? 'Redpanda Cloud' : ''
+
+    const categories = page.asciidoc?.attributes['page-categories']
+    ? page.asciidoc.attributes['page-categories'].split(',').map(category => category.trim())
+    : []
 
-    const indexItem = {
+    var indexItem = {
       title: documentTitle,
-      product: component.title,
       version: version,
       text: text,
-      breadcrumbs: breadcrumbs,
       intro: intro,
       objectID: urlPath + page.pub.url,
       titles: titles,
-      keywords: keywords,
+      categories: categories,
       unixTimestamp: unixTimestamp,
-      type: 'Doc',
-      _tags: [tag, 'docs']
     }
 
+    if (component.name !== 'redpanda-labs') {
+      indexItem.product = component.title;
+      indexItem.breadcrumbs = breadcrumbs;
+      indexItem.type = 'Doc';
+      indexItem._tags = [tag, 'docs'];
+    } else {
+      indexItem.deployment = deployment;
+      indexItem.type = 'Lab';
+      indexItem.interactive = false;
+      indexItem._tags = ['labs'];
+    }
     algolia[cname][version].push(indexItem)
     algoliaCount++
   }
-
   return algolia
 }
 

package/extensions/algolia-indexer/index.js

@@ -114,7 +114,7 @@ function register({
     }
 
     for (const [objectID, obj] of existingObjectsMap) {
-      if (obj.type === 'Doc' && !obj._tags.includes('apis') || !obj.type) {
+      if ((obj.type === 'Doc' && !obj._tags.includes('apis')) || (!obj.type) || (obj.type === 'Lab' && !obj.interactive)) {
         objectsToDelete.push(objectID)
       }
     }

package/extensions/find-related-docs.js

@@ -0,0 +1,70 @@
+'use strict';
+
+module.exports.register = function ({ config }) {
+  const logger = this.getLogger('related-docs-extension');
+
+  this.on('documentsConverted', async ({ contentCatalog, siteCatalog }) => {
+    const labs = contentCatalog.findBy({ component: 'redpanda-labs', family: 'page' });
+    labs.forEach((labPage) => {
+      const relatedDocs = []
+      const relatedLabs = []
+      const sourceAttributes = labPage.asciidoc.attributes
+      const pageCategories = sourceAttributes['page-categories'];
+      if (!pageCategories) return;
+      const sourceCategoryList = pageCategories.split(',').map(c => c.trim());
+      const sourceDeploymentType = getDeploymentType(sourceAttributes)
+      const docs = contentCatalog.findBy({ component: 'ROOT', family: 'page' });
+      docs.forEach((docPage) => {
+        const related = findRelated(docPage, sourceCategoryList, sourceDeploymentType, logger)
+        related && relatedDocs.push(related)
+      })
+      labs.forEach((targetLabPage) => {
+        if (targetLabPage === labPage) return;
+
+        const related = findRelated(targetLabPage, sourceCategoryList, sourceDeploymentType, logger);
+        if (related) relatedLabs.push(related);
+      });
+
+      // Store related docs and labs in the lab page attributes
+      if (relatedDocs.length > 0) {
+        labPage.asciidoc.attributes['page-related-docs'] = JSON.stringify(relatedDocs);
+      }
+
+      if (relatedLabs.length > 0) {
+        labPage.asciidoc.attributes['page-related-labs'] = JSON.stringify(relatedLabs);
+      }
+
+      if (relatedDocs.length > 0 || relatedLabs.length > 0) {
+        logger.info(`Set related docs and labs attributes for ${labPage.asciidoc.doctitle}`);
+      }
+    })
+  })
+}
+
+function findRelated(docPage, sourceCategoryList, sourceDeploymentType, logger) {
+  const targetAttributes = docPage.asciidoc.attributes
+  const pageCategories = targetAttributes['page-categories'];
+  if (!pageCategories) return null;
+  const targetCategoryList = pageCategories.split(',').map(c => c.trim());
+  const targetDeploymentType = getDeploymentType(targetAttributes)
+  const categoryMatch = hasMatchingCategory(sourceCategoryList, targetCategoryList)
+  if (categoryMatch && (!targetDeploymentType ||sourceDeploymentType === targetDeploymentType)) {
+    return {
+      title: docPage.asciidoc.doctitle,
+      url: docPage.pub.url,
+    }
+  }
+  return null
+}
+
+function getDeploymentType (attributes) {
+  return attributes['env-kubernetes'] ? 'Kubernetes'
+    : attributes['env-linux'] ? 'Linux'
+      : attributes['env-docker'] ? 'Docker'
+        : attributes.cloud ? 'Redpanda Cloud' 
+        : ''
+}
+
+function hasMatchingCategory (sourcePageCategories, targetPageCategories) {
+  return sourcePageCategories.every((category) => targetPageCategories.includes(category))
+}

package/extensions/find-related-labs.js

@@ -0,0 +1,52 @@
+'use strict';
+
+module.exports.register = function ({ config }) {
+  const logger = this.getLogger('related-labs-extension');
+
+  this.on('documentsConverted', async ({ contentCatalog, siteCatalog }) => {
+    const docs = contentCatalog.findBy({ component: 'ROOT', family: 'page' });
+    docs.forEach((docPage) => {
+      const relatedLabs = []
+      const sourceAttributes = docPage.asciidoc.attributes
+      const pageCategories = sourceAttributes['page-categories'];
+      if (!pageCategories) return;
+      const sourceCategoryList = pageCategories.split(',').map(c => c.trim());
+      const sourceDeploymentType = getDeploymentType(sourceAttributes)
+      const labs = contentCatalog.findBy({ component: 'redpanda-labs', family: 'page' });
+      labs.forEach((labPage) => {
+        const related = findRelated(labPage, sourceCategoryList, sourceDeploymentType, logger)
+        related && relatedLabs.push(related)
+      })
+      if (!relatedLabs.length) return
+      docPage.asciidoc.attributes['page-related-labs'] = JSON.stringify(relatedLabs)
+      logger.info(`Set page-related-labs attribute for ${docPage.asciidoc.doctitle} to ${docPage.asciidoc.attributes['page-related-labs']}`)
+    })
+  })
+}
+
+function findRelated(labPage, sourceCategoryList, sourceDeploymentType, logger) {
+  const targetAttributes = labPage.asciidoc.attributes
+  const pageCategories = targetAttributes['page-categories'];
+  if (!pageCategories) return null;
+  const targetCategoryList = pageCategories.split(',').map(c => c.trim());
+  const targetDeploymentType = getDeploymentType(targetAttributes)
+  const categoryMatch = hasMatchingCategory(sourceCategoryList, targetCategoryList)
+  if (categoryMatch && (!targetDeploymentType ||sourceDeploymentType === targetDeploymentType || targetDeploymentType === 'Docker')) {
+    return {
+      title: labPage.asciidoc.doctitle,
+      url: labPage.pub.url,
+    }
+  }
+  return null
+}
+
+function getDeploymentType (attributes) {
+  return attributes['env-kubernetes'] ? 'Kubernetes'
+    : attributes['env-linux'] ? 'Linux'
+      : attributes['env-docker'] ? 'Docker'
+        : attributes.cloud ? 'Redpanda Cloud' : ''
+}
+
+function hasMatchingCategory (sourcePageCategories, targetPageCategories) {
+  return sourcePageCategories.every((category) => targetPageCategories.includes(category))
+}

package/extensions/replace-attributes-in-attachments.js

@@ -4,19 +4,34 @@ module.exports.register = function ({ config }) {
 
   const sanitizeAttributeValue = (value) => String(value).replace("@", "");
 
-  this.on('documentsConverted', ({contentCatalog}) => {
+  this.on('contentClassified', ({contentCatalog}) => {
     for (const { versions } of contentCatalog.getComponents()) {
       for (const { name: component, version, asciidoc } of versions) {
         const attachments = contentCatalog.findBy({ component, version, family });
-        if (component == 'api') continue
+        if (component == 'api') continue;
         for (const attachment of attachments) {
           let contentString = attachment['_contents'].toString('utf8');
-          if (!asciidoc.attributes) continue
+          if (!asciidoc.attributes) continue;
+
+          // Replace general attributes
           for (const key in asciidoc.attributes) {
             const placeholder = "{" + key + "}";
             const sanitizedValue = sanitizeAttributeValue(asciidoc.attributes[key]);
             contentString = contentString.replace(new RegExp(placeholder, 'g'), sanitizedValue);
           }
+
+
+          // Specific replacements for YAML files
+          if (attachment.out.path.endsWith('.yaml') || attachment.out.path.endsWith('.yml')) {
+            const redpandaVersionRegex = /(\$\{REDPANDA_VERSION[^\}]*\})/g;
+            const redpandaConsoleVersionRegex = /(\$\{REDPANDA_CONSOLE_VERSION[^\}]*\})/g;
+            const fullVersion = asciidoc.attributes['full-version'] ? sanitizeAttributeValue(asciidoc.attributes['full-version']) : '';
+            const latestConsoleVersion = asciidoc.attributes['latest-console-version'] ? sanitizeAttributeValue(asciidoc.attributes['latest-console-version']) : '';
+
+            contentString = contentString.replace(redpandaVersionRegex, fullVersion);
+            contentString = contentString.replace(redpandaConsoleVersionRegex, latestConsoleVersion);
+          }
+
           attachment['_contents'] = Buffer.from(contentString, "utf-8");
         }
       }

package/extensions/unlisted-pages.js

@@ -6,6 +6,7 @@ module.exports.register = function ({ config }) {
       contentCatalog.getComponents().forEach(({ versions }) => {
         versions.forEach(({ name: component, version, navigation: nav, url: defaultUrl }) => {
           if (component === 'api') return;
+          if (!nav) return
           const navEntriesByUrl = getNavEntriesByUrl(nav)
           const unlistedPages = contentCatalog
             .findBy({ component, version, family: 'page' })

package/extensions/validate-attributes.js

@@ -0,0 +1,88 @@
+/* Example use in the playbook
+* antora:
+    extensions:
+ *    - require: ./extensions/validate-attributes.js
+*/
+
+'use strict';
+
+module.exports.register = function ({ config }) {
+  const logger = this.getLogger('attribute-validation-extension');
+
+  this.on('documentsConverted', async ({ contentCatalog, siteCatalog }) => {
+    // Retrieve valid categories and subcategories from site attributes defined in add-global-attributes.js.
+    const validCategories = siteCatalog.attributeFile['page-valid-categories'];
+    const categoryMap = createCategoryMap(validCategories);
+    const pages = contentCatalog.findBy({ family: 'page' });
+    pages.forEach((page) => {
+      let pageCategories = page.asciidoc.attributes['page-categories'];
+      if (!pageCategories) return;
+      let pageCategoryList = pageCategories.split(',').map(c => c.trim());
+      const validatedCategories = validateCategories(pageCategoryList, page.asciidoc.attributes['page-relative-src-path'], categoryMap, logger);
+      page.asciidoc.attributes['page-categories'] = validatedCategories
+      processEnvironmentAttributes(page, logger);
+    })
+  })
+}
+
+function processEnvironmentAttributes(page, logger) {
+  const envAttributes = ['env-kubernetes', 'env-linux', 'env-docker'];
+  envAttributes.forEach(envAttr => {
+    if (page.asciidoc.attributes[envAttr]) {
+      // If the env attribute exists, set a corresponding page- attribute for use in the UI
+      const pageEnvAttr = `page-${envAttr}`;
+      page.asciidoc.attributes[pageEnvAttr] = true;
+      logger.info(`Set '${pageEnvAttr}' for ${page.asciidoc.attributes['page-relative-src-path']}`);
+    }
+  });
+}
+
+function validateCategories(pageCategoryList, pageInfo, categoryMap, logger) {
+  let isValid = true;
+  let adjustedCategories = new Set(pageCategoryList);
+
+  pageCategoryList.forEach(category => {
+    // Check if the current category is a subcategory
+    if (categoryMap.subcategories.has(category)) {
+      // Retrieve the parent category for the current subcategory
+      const parentCategory = categoryMap.parentMap.get(category);
+
+      // Check if the parent category is not already in the pageCategoryList
+      if (!adjustedCategories.has(parentCategory)) {
+        // Add the parent category since it's missing
+        adjustedCategories.add(parentCategory);
+        logger.info(`Added missing parent category '${parentCategory}' for subcategory '${category}' in ${pageInfo}`);
+      }
+    }
+    // Check if the current category is not a valid category or subcategory
+    else if (!categoryMap.categories.has(category)) {
+      logger.warn(`Invalid category '${category}' in ${pageInfo}`);
+      adjustedCategories.delete(category)
+      isValid = false;
+    }
+  });
+
+  if (!isValid) {
+      logger.warn(`Invalid categories detected. For a list of valid categories, see https://github.com/redpanda-data/docs/tree/shared/modules/ROOT/partials/valid-categories.yml`);
+  }
+  return Array.from(adjustedCategories).join(', ');
+}
+
+function createCategoryMap(validCategories) {
+  const categoryMap = {
+    categories: new Set(),
+    subcategories: new Set(),
+    parentMap: new Map()
+  };
+
+  validCategories.forEach(categoryInfo => {
+    categoryMap.categories.add(categoryInfo.category);
+    if (categoryInfo.subcategories) {
+      categoryInfo.subcategories.forEach(subcat => {
+        categoryMap.subcategories.add(subcat.category);
+        categoryMap.parentMap.set(subcat.category, categoryInfo.category);
+      });
+    }
+  });
+  return categoryMap
+}

package/extensions/version-fetcher/{getLatestConsoleVersion.js → get-latest-console-version.js}

@@ -19,15 +19,12 @@ const github = new OctokitWithRetries(githubOptions);
 var latestConsoleReleaseVersion;
 
 module.exports = async () => {
-  await github.rest.repos.getLatestRelease({
-    owner,
-    repo,
-  }).then((release => {
-    const tag = release.data.tag_name;
-    latestConsoleReleaseVersion = tag.replace('v','');
-  })).catch((error => {
-    console.error(error)
-    return null
-  }))
-  return latestConsoleReleaseVersion;
+  try {
+    const release = await github.rest.repos.getLatestRelease({ owner, repo });
+    latestConsoleReleaseVersion = release.data.tag_name.replace('v','');
+    return latestConsoleReleaseVersion;
+  } catch (error) {
+    console.error(error);
+    return null;
+  }
 };

package/extensions/version-fetcher/get-latest-operator-version.js

@@ -0,0 +1,28 @@
+// Fetch the latest release version from GitHub
+const { Octokit } = require("@octokit/rest");
+const { retry } = require("@octokit/plugin-retry");
+const OctokitWithRetries = Octokit.plugin(retry);
+const owner = 'redpanda-data';
+const repo = 'redpanda-operator';
+
+let githubOptions = {
+  userAgent: 'Redpanda Docs',
+  baseUrl: 'https://api.github.com',
+};
+
+if (process.env.REDPANDA_GITHUB_TOKEN) {
+  githubOptions.auth = process.env.REDPANDA_GITHUB_TOKEN;
+}
+
+const github = new OctokitWithRetries(githubOptions);
+
+module.exports = async () => {
+  try {
+    const release = await github.rest.repos.getLatestRelease({ owner, repo });
+    latestOperatorReleaseVersion = release.data.tag_name;
+    return latestOperatorReleaseVersion;
+  } catch (error) {
+    console.error(error);
+    return null;
+  }
+};

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

@@ -0,0 +1,39 @@
+// Fetch the latest release version from GitHub
+const { Octokit } = require("@octokit/rest");
+const { retry } = require("@octokit/plugin-retry");
+const OctokitWithRetries = Octokit.plugin(retry);
+const owner = 'redpanda-data';
+const repo = 'redpanda';
+
+let githubOptions = {
+  userAgent: 'Redpanda Docs',
+  baseUrl: 'https://api.github.com',
+};
+
+if (process.env.REDPANDA_GITHUB_TOKEN) {
+  githubOptions.auth = process.env.REDPANDA_GITHUB_TOKEN;
+}
+
+const github = new OctokitWithRetries(githubOptions);
+
+module.exports = async () => {
+  try {
+    // Fetch the latest release
+    const release = await github.rest.repos.getLatestRelease({ owner, repo });
+    const tag = release.data.tag_name;
+    latestRedpandaReleaseVersion = tag.replace('v', '');
+
+    // Get reference of the tag
+    const tagRef = await github.rest.git.getRef({ owner, repo, ref: `tags/${tag}` });
+    const releaseSha = tagRef.data.object.sha;
+
+    // Get the tag object to extract the commit hash
+    const tagData = await github.rest.git.getTag({ owner, repo, tag_sha: releaseSha });
+    latestRedpandaReleaseCommitHash = tagData.data.object.sha.substring(0, 7);
+
+    return [latestRedpandaReleaseVersion, latestRedpandaReleaseCommitHash];
+  } catch (error) {
+    console.error(error);
+    return [null, null];
+  }
+};

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

@@ -4,8 +4,9 @@ antora:
   - require: ./extensions/setLatestVersion.js
 */
 
-const GetLatestRedpandaVersion = require('./getLatestRedpandaVersion');
-const GetLatestConsoleVersion = require('./getLatestConsoleVersion');
+const GetLatestRedpandaVersion = require('./get-latest-redpanda-version');
+const GetLatestConsoleVersion = require('./get-latest-console-version');
+const GetLatestOperatorVersion = require('./get-latest-operator-version');
 const chalk = require('chalk')
 
 
@@ -15,25 +16,28 @@ module.exports.register = function ({ config }) {
     logger.warn('REDPANDA_GITHUB_TOKEN environment variable not set. Attempting unauthenticated request.');
   }
   this
-    .on('contentClassified', async ({ siteCatalog,contentCatalog }) => {
+    .on('contentClassified', async ({ contentCatalog }) => {
       try {
         const LatestRedpandaVersion = await GetLatestRedpandaVersion();
         const LatestConsoleVersion = await GetLatestConsoleVersion();
+        const LatestOperatorVersion = await GetLatestOperatorVersion();
         if (LatestRedpandaVersion.length !== 2 || !LatestRedpandaVersion[0]) {
           logger.warn('Failed to get the latest Redpanda version - using defaults');
         }
         if (!LatestConsoleVersion) {
           logger.warn(`Failed to get latest Console version from GitHub - using default`)
         }
+        if (!LatestOperatorVersion) {
+          logger.warn(`Failed to get latest Operator version from GitHub - using default`)
+        }
         const components = await contentCatalog.getComponents();
         for (let i = 0; i < components.length; i++) {
           let component = components[i];
-          if (component.name !== 'ROOT' && component.name !== 'preview') continue
 
           component.versions.forEach(({name, version, asciidoc}) => {
             if (LatestConsoleVersion) {
               asciidoc.attributes['latest-console-version'] = `${LatestConsoleVersion}`;
-              console.log(`${chalk.green('Set Redpanda Console version to')} ${chalk.bold(LatestConsoleVersion)} in ${name} ${version}`);
+              logger.info(`Set Redpanda Console version to')} ${LatestConsoleVersion} in ${name} ${version}`);
             }
           })
 
@@ -49,8 +53,16 @@ module.exports.register = function ({ config }) {
 
           component.latest.asciidoc.attributes['full-version'] = `${LatestRedpandaVersion[0]}`;
           component.latest.asciidoc.attributes['latest-release-commit'] = `${LatestRedpandaVersion[1]}`;
-          console.log(`${chalk.green('Set the latest Redpanda version to')} ${chalk.bold(LatestRedpandaVersion[0])} ${chalk.bold(LatestRedpandaVersion[1])}`)
+          logger.info(`Set the latest Redpanda version to ${LatestRedpandaVersion[0]} ${LatestRedpandaVersion[1]}`)
+
+          if (!LatestOperatorVersion) continue;
+
+          component.latest.asciidoc.attributes['latest-operator-version'] = `${LatestOperatorVersion}`;
+          logger.info(`Set the latest Redpanda Operator version to ${LatestOperatorVersion}`)
         }
+        console.log(`${chalk.green('Set Redpanda Console version to')} ${chalk.bold(LatestConsoleVersion)}`);
+        console.log(`${chalk.green('Set the latest Redpanda version to')} ${chalk.bold(LatestRedpandaVersion[0])} ${chalk.bold(LatestRedpandaVersion[1])}`)
+        console.log(`${chalk.green('Set the latest Redpanda Operator version to')} ${chalk.bold(LatestOperatorVersion)}`)
       } catch(error) {
         logger.warn(error)
       }

package/package.json

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

package/extensions/version-fetcher/getLatestRedpandaVersion.js

@@ -1,46 +0,0 @@
-// Fetch the latest release version from GitHub
-const { Octokit } = require("@octokit/rest");
-const { retry } = require("@octokit/plugin-retry");
-const OctokitWithRetries = Octokit.plugin(retry);
-const owner = 'redpanda-data';
-const repo = 'redpanda';
-
-let githubOptions = {
-  userAgent: 'Redpanda Docs',
-  baseUrl: 'https://api.github.com',
-};
-
-if (process.env.REDPANDA_GITHUB_TOKEN) {
-  githubOptions.auth = process.env.REDPANDA_GITHUB_TOKEN;
-}
-
-const github = new OctokitWithRetries(githubOptions);
-
-var latestRedpandaReleaseVersion;
-var latestRedpandaReleaseCommitHash;
-
-module.exports = async () => {
-  await github.rest.repos.getLatestRelease({
-    owner,
-    repo,
-  }).then(async function(release) {
-    const tag = release.data.tag_name;
-    latestRedpandaReleaseVersion = tag.replace('v','');
-    await github.rest.git.getRef({
-      owner,
-      repo,
-      ref: `/tags/${tag}`,
-    }).then(async function(tagRef) {
-      const releaseSha = tagRef.data.object.sha;
-      await github.rest.git.getTag({
-        owner,
-        repo,
-        tag_sha: releaseSha,
-      }).then((tag => latestRedpandaReleaseCommitHash = tag.data.object.sha.substring(0, 7)))
-    })
-  }).catch((error => {
-    console.error(error)
-    return null
-  }))
-  return [latestRedpandaReleaseVersion, latestRedpandaReleaseCommitHash];
-};