@redpanda-data/docs-extensions-and-macros 4.13.1 → 4.13.3

package/extensions/generate-rp-connect-categories.js

@@ -1,36 +1,54 @@
 'use strict'
 
+/**
+ * Redpanda Connect Category Aggregation Extension
+ *
+ * IMPORTANT: This extension depends on generate-rp-connect-info running first.
+ * Both extensions use 'contentClassified' event. The generate-rp-connect-info
+ * extension returns a Promise, so Antora will wait for it to complete before
+ * running this extension (extensions are processed in playbook order).
+ *
+ * Ensure generate-rp-connect-info is listed BEFORE this extension in your playbook.
+ */
 module.exports.register = function ({ config }) {
   const logger = this.getLogger('redpanda-connect-category-aggregation-extension')
 
-  this.once('contentClassified', ({ siteCatalog, contentCatalog }) => {
+  this.on('contentClassified', ({ contentCatalog }) => {
     const redpandaConnect = contentCatalog.getComponents().find(component => component.name === 'redpanda-connect')
+
     if (!redpandaConnect || !redpandaConnect.latest) {
       logger.warn('Could not find the redpanda-connect component. Skipping category creation.')
       return
     }
 
     const descriptions = redpandaConnect.latest.asciidoc.attributes.categories
-    const componentNameMap = redpandaConnect.latest.asciidoc.attributes.components
-    const certifiedConnectors = redpandaConnect.latest.asciidoc.attributes['certified-components']
-    const enterpriseConnectors = redpandaConnect.latest.asciidoc.attributes['enterprise-components']
+    const csvData = redpandaConnect.latest.asciidoc.attributes.csvData
 
-    if (!descriptions || !componentNameMap || !certifiedConnectors || !enterpriseConnectors) {
-      if (!descriptions) {
-        logger.error('No categories attribute found in redpanda-connect component')
-      }
-      if (!componentNameMap) {
-        logger.error('No components attribute found in redpanda-connect component')
-      }
-      if (!certifiedConnectors) {
-        logger.error('No certified-components attribute found in redpanda-connect component')
-      }
-      if (!enterpriseConnectors) {
-        logger.error('No enterprise-components attribute found in redpanda-connect component')
-      }
+    if (!descriptions) {
+      logger.error('No categories attribute found in redpanda-connect component')
+      return
+    }
+
+    if (!csvData || !csvData.data) {
+      logger.error('No csvData attribute found in redpanda-connect component.')
+      logger.error('Ensure generate-rp-connect-info extension is listed BEFORE this extension in your playbook.')
       return
     }
 
+    // Build lookup maps from CSV data
+    const supportLookup = new Map()
+    for (const row of csvData.data) {
+      const connector = row.connector
+      if (connector) {
+        supportLookup.set(connector, {
+          supportLevel: (row.support_level || 'community').toLowerCase(),
+          isEnterprise: row.is_licensed === 'Yes'
+        })
+      }
+    }
+
+    logger.info(`Loaded support data for ${supportLookup.size} connectors from CSV`)
+
     const connectCategoriesData = {}
     const flatComponentsData = []
     const driverSupportData = {}
@@ -38,88 +56,128 @@ module.exports.register = function ({ config }) {
     const types = Object.keys(descriptions)
 
     // Initialize connectCategoriesData for each type
-    types.forEach(type => {
+    for (const type of types) {
       connectCategoriesData[type] = []
-    })
+    }
 
     try {
       const files = contentCatalog.findBy({ component: 'redpanda-connect', family: 'page' })
 
-      files.forEach(file => {
-        let content = file.contents.toString('utf8')
-        const categoryMatch = /:categories: (.*)/.exec(content)
-        const typeMatch = /:type: (.*)/.exec(content)
-        const statusMatch = /:status: (.*)/.exec(content)
-        const driverSupportMatch = /:driver-support: (.*)/.exec(content)
-        const cacheSupportMatch = /:cache-support: (.*)/.exec(content)
+      for (const file of files) {
+        // Prefer using page.asciidoc.attributes when available
+        const attrs = file.asciidoc?.attributes || {}
+
+        // Get attributes - prefer API, fallback to content parsing
+        const fileType = attrs.type || extractAttribute(file, 'type')
+        const categories = attrs.categories || extractAttribute(file, 'categories')
+        const status = attrs.status || extractAttribute(file, 'status')
+        const driverSupport = attrs['driver-support'] || extractAttribute(file, 'driver-support')
+        const cacheSupport = attrs['cache-support'] || extractAttribute(file, 'cache-support')
+        const commercialNames = attrs['page-commercial-names'] || extractAttribute(file, 'page-commercial-names')
+
         const pubUrl = file.pub.url
         const name = file.src.stem
 
-        if (typeMatch) {
-          const fileType = typeMatch[1]
-
-          let status = statusMatch ? statusMatch[1] : 'community'
+        if (!fileType) continue
 
-          // Skip deprecated components
-          if (status === 'deprecated') return
+        let componentStatus = status || 'community'
 
-          const isCertified = certifiedConnectors.some(connector => connector.name === name)
+        // Skip deprecated components
+        if (componentStatus === 'deprecated') continue
 
-          const isEnterprise = enterpriseConnectors.some(connector => connector === name)
+        // Get support level from CSV data
+        const csvInfo = supportLookup.get(name)
+        const isEnterprise = csvInfo?.isEnterprise || false
 
-          // Override status to "certified" if in the lookup table
-          if (isCertified || isEnterprise) {
-            status = 'certified'
+        // Determine status from CSV support level (CSV takes precedence)
+        if (csvInfo) {
+          if (csvInfo.supportLevel === 'certified' || csvInfo.supportLevel === 'enterprise') {
+            componentStatus = 'certified'
           } else {
-            status = 'community'
+            componentStatus = csvInfo.supportLevel
           }
+        }
 
-          // Find the common name
-          const componentNameEntry = componentNameMap.find(component => component.key === name)
-          const commonName = componentNameEntry ? componentNameEntry.name : name
+        // Parse commercial names and use first as display name
+        let commonName = name // Default to connector key name
+        if (commercialNames) {
+          const names = commercialNames.split(',').map(n => n.trim()).filter(n => n)
+          if (names.length > 0) {
+            commonName = names[0]
+          }
+        }
 
-          // Populate connectCategoriesData
-          if (types.includes(fileType) && categoryMatch) {
-            const categories = categoryMatch[1].replace(/[\[\]"]/g, '').split(',').map(category => category.trim())
-            categories.forEach(category => {
-              let categoryObj = connectCategoriesData[fileType].find(cat => cat.name === category)
+        // Populate connectCategoriesData
+        if (types.includes(fileType) && categories) {
+          const categoryList = categories.replace(/[\[\]"]/g, '').split(',').map(cat => cat.trim())
 
-              if (!categoryObj) {
-                categoryObj = descriptions[fileType].find(desc => desc.name === category) || { name: category, description: "" }
-                categoryObj.items = []
-                connectCategoriesData[fileType].push(categoryObj)
-              }
+          for (const category of categoryList) {
+            let categoryObj = connectCategoriesData[fileType].find(cat => cat.name === category)
 
-              categoryObj.items.push({ name: commonName, url: pubUrl, status: status })
-            })
-          }
+            if (!categoryObj) {
+              categoryObj = descriptions[fileType].find(desc => desc.name === category) || { name: category, description: '' }
+              categoryObj.items = []
+              connectCategoriesData[fileType].push(categoryObj)
+            }
 
-          // Populate flatComponentsData
-          let flatItem = flatComponentsData.find(item => item.name === commonName)
-          if (!flatItem) {
-            flatItem = { name: commonName, originalName: name, support: status, types: [], enterprise: isEnterprise ? true : false}
-            flatComponentsData.push(flatItem)
+            categoryObj.items.push({ name: commonName, url: pubUrl, status: componentStatus })
           }
+        }
 
-          if (!flatItem.types.some(type => type.type === fileType)) {
-            flatItem.types.push({ type: fileType, url: pubUrl, enterprise: isEnterprise? true : false, support: status})
+        // Populate flatComponentsData
+        let flatItem = flatComponentsData.find(item => item.name === commonName)
+        if (!flatItem) {
+          flatItem = {
+            name: commonName,
+            originalName: name,
+            support: componentStatus,
+            types: [],
+            enterprise: isEnterprise
           }
+          flatComponentsData.push(flatItem)
+        }
 
-          // Populate support data
-          if (driverSupportMatch) driverSupportData[name] = driverSupportMatch[1]
-          if (cacheSupportMatch) cacheSupportData[name] = cacheSupportMatch[1]
+        if (!flatItem.types.some(t => t.type === fileType)) {
+          flatItem.types.push({
+            type: fileType,
+            url: pubUrl,
+            enterprise: isEnterprise,
+            support: componentStatus
+          })
         }
-      })
+
+        // Populate support data
+        if (driverSupport) driverSupportData[name] = driverSupport
+        if (cacheSupport) cacheSupportData[name] = cacheSupport
+      }
 
       redpandaConnect.latest.asciidoc.attributes.connectCategoriesData = connectCategoriesData
       redpandaConnect.latest.asciidoc.attributes.flatComponentsData = flatComponentsData
       redpandaConnect.latest.asciidoc.attributes.driverSupportData = driverSupportData
       redpandaConnect.latest.asciidoc.attributes.cacheSupportData = cacheSupportData
 
-      logger.debug(`Added Redpanda Connect data to latest Asciidoc object.`)
-      logger.debug(`${JSON.stringify({ connectCategoriesData, flatComponentsData }, null, 2)}`)
+      logger.info(`Processed ${flatComponentsData.length} components across ${types.length} types`)
+      logger.debug(`Categories data: ${JSON.stringify(connectCategoriesData, null, 2)}`)
     } catch (error) {
       logger.error(`Error processing Redpanda Connect files: ${error.message}`)
+      logger.error(error.stack)
     }
   })
+
+  /**
+   * Extract attribute from file contents when page.asciidoc.attributes is not available.
+   * This is a fallback for when attributes haven't been parsed yet.
+   */
+  function extractAttribute (file, attrName) {
+    if (!file.contents) return null
+
+    try {
+      const content = file.contents.toString('utf8')
+      const regex = new RegExp(`:${attrName}:\\s*(.*)`)
+      const match = regex.exec(content)
+      return match ? match[1].trim() : null
+    } catch {
+      return null
+    }
+  }
 }