@redpanda-data/docs-extensions-and-macros 4.8.1 → 4.9.1

package/tools/property-extractor/compare-properties.js

@@ -0,0 +1,378 @@
+#!/usr/bin/env node
+
+/**
+ * Property Comparison Tool
+ * 
+ * Compares two property JSON files and generates a detailed report of:
+ * - New properties added
+ * - Properties with changed defaults
+ * - Properties with changed descriptions
+ * - Properties with changed types
+ * - Deprecated properties
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Recursively compares two values for structural deep equality.
+ *
+ * - Returns true if values are strictly equal (`===`).
+ * - Returns false if types differ or either is `null`/`undefined` while the other is not.
+ * - Arrays: ensures same length and recursively compares each element.
+ * - Objects: compares own enumerable keys (order-insensitive) and recursively compares corresponding values.
+ *
+ * @param {*} a - First value to compare.
+ * @param {*} b - Second value to compare.
+ * @returns {boolean} True if the two values are deeply equal.
+ */
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (a == null || b == null) return false;
+  if (typeof a !== typeof b) return false;
+  
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    return a.every((val, i) => deepEqual(val, b[i]));
+  }
+  
+  if (typeof a === 'object' && typeof b === 'object') {
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length) return false;
+    return keysA.every(key => keysB.includes(key) && deepEqual(a[key], b[key]));
+  }
+  
+  return false;
+}
+
+/**
+ * Format a value for concise human-readable display in comparison reports.
+ *
+ * Converts various JavaScript values into short string representations used
+ * in the report output:
+ * - null/undefined → `'null'`
+ * - Array:
+ *   - empty → `'[]'`
+ *   - single item → `[<formatted item>]` (recursively formatted)
+ *   - multiple items → `'[<n> items]'`
+ * - Object → JSON string via `JSON.stringify`
+ * - String → quoted; truncated with `...` if longer than 50 characters
+ * - Other primitives → `String(value)`
+ *
+ * @param {*} value - The value to format for display.
+ * @return {string} A concise string suitable for report output.
+ */
+function formatValue(value) {
+  if (value === null || value === undefined) {
+    return 'null';
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0) return '[]';
+    if (value.length === 1) return `[${formatValue(value[0])}]`;
+    return `[${value.length} items]`;
+  }
+  if (typeof value === 'object') {
+    return JSON.stringify(value);
+  }
+  if (typeof value === 'string') {
+    return value.length > 50 ? `"${value.substring(0, 50)}..."` : `"${value}"`;
+  }
+  return String(value);
+}
+
+/**
+ * Extracts a flat map of property definitions from a parsed JSON schema or similar object.
+ *
+ * If the input contains a top-level `properties` object, that object is returned directly.
+ * Otherwise, the function scans the root keys (excluding `definitions`) and returns any
+ * entries that look like property definitions (an object with at least one of `type`,
+ * `description`, or `default`).
+ *
+ * @param {Object} data - Parsed JSON data to scan for property definitions.
+ * @returns {Object} A map of property definitions (key → property object). Returns an empty object if none found.
+ */
+function extractProperties(data) {
+  // Properties are nested under a 'properties' key in the JSON structure
+  if (data.properties && typeof data.properties === 'object') {
+    return data.properties;
+  }
+  
+  // Fallback: look for properties at root level
+  const properties = {};
+  for (const [key, value] of Object.entries(data)) {
+    if (key !== 'definitions' && typeof value === 'object' && value !== null) {
+      // Check if this looks like a property definition
+      if (value.hasOwnProperty('type') || value.hasOwnProperty('description') || value.hasOwnProperty('default')) {
+        properties[key] = value;
+      }
+    }
+  }
+
+  return properties;
+}
+
+/**
+ * Compare two property JSON structures and produce a detailed change report.
+ *
+ * Compares properties extracted from oldData and newData and classifies differences
+ * into newProperties, changedDefaults, changedDescriptions, changedTypes,
+ * deprecatedProperties (newly deprecated in newData), and removedProperties.
+ * Description fields in the report are truncated for brevity; default equality
+ * is determined by a deep structural comparison.
+ *
+ * @param {Object} oldData - Parsed JSON of the older property file.
+ * @param {Object} newData - Parsed JSON of the newer property file.
+ * @param {string} oldVersion - Version string corresponding to oldData.
+ * @param {string} newVersion - Version string corresponding to newData.
+ * @return {Object} Report object with arrays: newProperties, changedDefaults,
+ *   changedDescriptions, changedTypes, deprecatedProperties, removedProperties.
+ */
+function compareProperties(oldData, newData, oldVersion, newVersion) {
+  const oldProps = extractProperties(oldData);
+  const newProps = extractProperties(newData);
+  
+  const report = {
+    newProperties: [],
+    changedDefaults: [],
+    changedDescriptions: [],
+    changedTypes: [],
+    deprecatedProperties: [],
+    removedProperties: []
+  };
+  
+  // Find new properties
+  for (const [name, prop] of Object.entries(newProps)) {
+    if (!oldProps.hasOwnProperty(name)) {
+      report.newProperties.push({
+        name,
+        type: prop.type,
+        default: prop.default,
+        description: prop.description ? prop.description.substring(0, 100) + '...' : 'No description'
+      });
+    }
+  }
+  
+  // Find changed properties
+  for (const [name, oldProp] of Object.entries(oldProps)) {
+    if (newProps.hasOwnProperty(name)) {
+      const newProp = newProps[name];
+      
+      // Check for deprecation first (using is_deprecated field only)
+      const isNewlyDeprecated = newProp.is_deprecated === true && 
+        oldProp.is_deprecated !== true;
+      
+      if (isNewlyDeprecated) {
+        report.deprecatedProperties.push({
+          name,
+          reason: newProp.deprecatedReason || 'Property marked as deprecated'
+        });
+        // Skip other change detection for deprecated properties
+        continue;
+      }
+      
+      // Only check other changes if property is not newly deprecated
+      // Check for default value changes
+      if (!deepEqual(oldProp.default, newProp.default)) {
+        report.changedDefaults.push({
+          name,
+          oldDefault: oldProp.default,
+          newDefault: newProp.default
+        });
+      }
+      
+      // Check for description changes
+      if (oldProp.description !== newProp.description) {
+        report.changedDescriptions.push({
+          name,
+          oldDescription: oldProp.description ? oldProp.description.substring(0, 50) + '...' : 'No description',
+          newDescription: newProp.description ? newProp.description.substring(0, 50) + '...' : 'No description'
+        });
+      }
+      
+      // Check for type changes
+      if (oldProp.type !== newProp.type) {
+        report.changedTypes.push({
+          name,
+          oldType: oldProp.type,
+          newType: newProp.type
+        });
+      }
+    } else {
+      // Property was removed
+      report.removedProperties.push({
+        name,
+        type: oldProp.type,
+        description: oldProp.description ? oldProp.description.substring(0, 100) + '...' : 'No description'
+      });
+    }
+  }
+  
+  return report;
+}
+
+/**
+ * Print a human-readable console report summarizing property differences between two versions.
+ *
+ * The report includes sections for new properties, properties with changed defaults,
+ * changed types, updated descriptions, newly deprecated properties (with reason), and removed properties.
+ *
+ * @param {Object} report - Comparison report object returned by compareProperties().
+ * @param {string} oldVersion - Label for the old version (displayed as the "from" version).
+ * @param {string} newVersion - Label for the new version (displayed as the "to" version).
+ */
+function generateConsoleReport(report, oldVersion, newVersion) {
+  console.log('\n' + '='.repeat(60));
+  console.log(`📋 Property Changes Report (${oldVersion} → ${newVersion})`);
+  console.log('='.repeat(60));
+  
+  if (report.newProperties.length > 0) {
+    console.log(`\n➤ New properties (${report.newProperties.length}):`);
+    report.newProperties.forEach(prop => {
+      console.log(`   • ${prop.name} (${prop.type}) — default: ${formatValue(prop.default)}`);
+    });
+  } else {
+    console.log('\n➤ No new properties.');
+  }
+  
+  if (report.changedDefaults.length > 0) {
+    console.log(`\n➤ Properties with changed defaults (${report.changedDefaults.length}):`);
+    report.changedDefaults.forEach(prop => {
+      console.log(`   • ${prop.name}:`);
+      console.log(`     - Old: ${formatValue(prop.oldDefault)}`);
+      console.log(`     - New: ${formatValue(prop.newDefault)}`);
+    });
+  } else {
+    console.log('\n➤ No default value changes.');
+  }
+  
+  if (report.changedTypes.length > 0) {
+    console.log(`\n➤ Properties with changed types (${report.changedTypes.length}):`);
+    report.changedTypes.forEach(prop => {
+      console.log(`   • ${prop.name}: ${prop.oldType} → ${prop.newType}`);
+    });
+  }
+  
+  if (report.changedDescriptions.length > 0) {
+    console.log(`\n➤ Properties with updated descriptions (${report.changedDescriptions.length}):`);
+    report.changedDescriptions.forEach(prop => {
+      console.log(`   • ${prop.name} — description updated`);
+    });
+  }
+  
+  if (report.deprecatedProperties.length > 0) {
+    console.log(`\n➤ Newly deprecated properties (${report.deprecatedProperties.length}):`);
+    report.deprecatedProperties.forEach(prop => {
+      console.log(`   • ${prop.name} — ${prop.reason}`);
+    });
+  }
+  
+  if (report.removedProperties.length > 0) {
+    console.log(`\n➤ Removed properties (${report.removedProperties.length}):`);
+    report.removedProperties.forEach(prop => {
+      console.log(`   • ${prop.name} (${prop.type})`);
+    });
+  }
+  
+  console.log('\n' + '='.repeat(60));
+}
+
+/**
+ * Write a structured JSON comparison report to disk.
+ *
+ * Produces a JSON file containing a comparison header (old/new versions and timestamp),
+ * a summary with counts for each change category, and the full details object passed as `report`.
+ *
+ * @param {Object} report - Comparison details object produced by compareProperties; expected to contain arrays: `newProperties`, `changedDefaults`, `changedDescriptions`, `changedTypes`, `deprecatedProperties`, and `removedProperties`.
+ * @param {string} oldVersion - The previous version identifier included in the comparison header.
+ * @param {string} newVersion - The new version identifier included in the comparison header.
+ * @param {string} outputPath - Filesystem path where the JSON report will be written.
+ */
+function generateJsonReport(report, oldVersion, newVersion, outputPath) {
+  const jsonReport = {
+    comparison: {
+      oldVersion,
+      newVersion,
+      timestamp: new Date().toISOString()
+    },
+    summary: {
+      newProperties: report.newProperties.length,
+      changedDefaults: report.changedDefaults.length,
+      changedDescriptions: report.changedDescriptions.length,
+      changedTypes: report.changedTypes.length,
+      deprecatedProperties: report.deprecatedProperties.length,
+      removedProperties: report.removedProperties.length
+    },
+    details: report
+  };
+  
+  fs.writeFileSync(outputPath, JSON.stringify(jsonReport, null, 2));
+  console.log(`📄 Detailed JSON report saved to: ${outputPath}`);
+}
+
+/**
+ * Compare two property JSON files and produce a change report.
+ *
+ * Reads and parses the two JSON files at oldFilePath and newFilePath, compares their properties
+ * using compareProperties, prints a human-readable console report, and optionally writes a
+ * structured JSON report to outputDir/filename.
+ *
+ * Side effects:
+ * - Synchronously reads the two input files.
+ * - Writes a JSON report file when outputDir is provided (creates the directory if needed).
+ * - Logs progress and results to the console.
+ * - On error, logs the error and exits the process with code 1.
+ *
+ * @param {string} oldFilePath - Path to the old property JSON file.
+ * @param {string} newFilePath - Path to the new property JSON file.
+ * @param {string} oldVersion - Version label for the old file (used in reports).
+ * @param {string} newVersion - Version label for the new file (used in reports).
+ * @param {string|undefined} outputDir - Optional directory to write the JSON report; if falsy, no file is written.
+ * @param {string} [filename='property-changes.json'] - Name of the JSON report file to write inside outputDir.
+ * @returns {Object} The comparison report object produced by compareProperties.
+ */
+function comparePropertyFiles(oldFilePath, newFilePath, oldVersion, newVersion, outputDir, filename = 'property-changes.json') {
+  try {
+    console.log(`📊 Comparing property files:`);
+    console.log(`   Old: ${oldFilePath}`);
+    console.log(`   New: ${newFilePath}`);
+    
+    const oldData = JSON.parse(fs.readFileSync(oldFilePath, 'utf8'));
+    const newData = JSON.parse(fs.readFileSync(newFilePath, 'utf8'));
+    
+    const report = compareProperties(oldData, newData, oldVersion, newVersion);
+    
+    // Generate console report
+    generateConsoleReport(report, oldVersion, newVersion);
+    
+    // Generate JSON report if output directory provided
+    if (outputDir) {
+      fs.mkdirSync(outputDir, { recursive: true });
+      const jsonReportPath = path.join(outputDir, filename);
+      generateJsonReport(report, oldVersion, newVersion, jsonReportPath);
+    }
+    
+    return report;
+  } catch (error) {
+    console.error(`❌ Error comparing properties: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+// CLI usage
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  
+  if (args.length < 4) {
+    console.log('Usage: node compare-properties.js <old-file> <new-file> <old-version> <new-version> [output-dir] [filename]');
+    console.log('');
+    console.log('Example:');
+    console.log('  node compare-properties.js gen/v25.1.1-properties.json gen/v25.2.2-properties.json v25.1.1 v25.2.2 modules/reference property-changes-v25.1.1-to-v25.2.2.json');
+    process.exit(1);
+  }
+  
+  const [oldFile, newFile, oldVersion, newVersion, outputDir, filename] = args;
+  comparePropertyFiles(oldFile, newFile, oldVersion, newVersion, outputDir, filename);
+}
+
+module.exports = { comparePropertyFiles, compareProperties };

package/tools/property-extractor/generate-handlebars-docs.js

@@ -5,6 +5,19 @@ const path = require('path');
 const handlebars = require('handlebars');
 const helpers = require('./helpers');
 
+/**
+ * Handlebars documentation generator for Redpanda configuration properties.
+ * 
+ * Supports custom template overrides using environment variables:
+ * - TEMPLATE_PROPERTY_PAGE: Main property page template
+ * - TEMPLATE_PROPERTY: Individual property section template  
+ * - TEMPLATE_TOPIC_PROPERTY: Individual topic property section template
+ * - TEMPLATE_DEPRECATED_PROPERTY: Individual deprecated property section template
+ * - TEMPLATE_DEPRECATED: Deprecated properties page template
+ * 
+ * CLI Usage: node generate-handlebars-docs.js <input-file> <output-dir>
+ */
+
 // Register all helpers
 Object.entries(helpers).forEach(([name, fn]) => {
   if (typeof fn !== 'function') {
@@ -110,34 +123,74 @@ function getTemplatePath(defaultPath, envVar) {
 }
 
 /**
- * Registers Handlebars partials from template files
+ * Register Handlebars partials used to render property documentation.
+ *
+ * Loads templates from the local templates directory (overridable via environment
+ * variables handled by getTemplatePath) and registers three partials:
+ *  - "property" (uses cloud-aware `property-cloud.hbs` when enabled)
+ *  - "topic-property" (uses cloud-aware `topic-property-cloud.hbs` when enabled)
+ *  - "deprecated-property"
+ *
+ * @param {boolean} [hasCloudSupport=false] - If true, select cloud-aware templates for the `property` and `topic-property` partials.
+ * @throws {Error} If any required template file is missing or cannot be read; errors are rethrown after logging.
  */
-function registerPartials() {
+function registerPartials(hasCloudSupport = false) {
   const templatesDir = path.join(__dirname, 'templates');
   
-  // Register property partial
-  const propertyTemplatePath = getTemplatePath(
-    path.join(templatesDir, 'property.hbs'),
-    'TEMPLATE_PROPERTY'
-  );
-  const propertyTemplate = fs.readFileSync(propertyTemplatePath, 'utf8');
-  handlebars.registerPartial('property', propertyTemplate);
-  
-  // Register topic property partial
-  const topicPropertyTemplatePath = getTemplatePath(
-    path.join(templatesDir, 'topic-property.hbs'),
-    'TEMPLATE_TOPIC_PROPERTY'
-  );
-  const topicPropertyTemplate = fs.readFileSync(topicPropertyTemplatePath, 'utf8');
-  handlebars.registerPartial('topic-property', topicPropertyTemplate);
-  
-  // Register deprecated property partial
-  const deprecatedPropertyTemplatePath = getTemplatePath(
-    path.join(templatesDir, 'deprecated-property.hbs'),
-    'TEMPLATE_DEPRECATED_PROPERTY'
-  );
-  const deprecatedPropertyTemplate = fs.readFileSync(deprecatedPropertyTemplatePath, 'utf8');
-  handlebars.registerPartial('deprecated-property', deprecatedPropertyTemplate);
+  try {
+    console.log(`📝 Registering Handlebars templates (cloud support: ${hasCloudSupport ? 'enabled' : 'disabled'})`);
+    
+    // Register property partial (choose cloud or regular version)
+    const propertyTemplateFile = hasCloudSupport ? 'property-cloud.hbs' : 'property.hbs';
+    const propertyTemplatePath = getTemplatePath(
+      path.join(templatesDir, propertyTemplateFile),
+      'TEMPLATE_PROPERTY'
+    );
+    
+    if (!fs.existsSync(propertyTemplatePath)) {
+      throw new Error(`Property template not found: ${propertyTemplatePath}`);
+    }
+    
+    const propertyTemplate = fs.readFileSync(propertyTemplatePath, 'utf8');
+    handlebars.registerPartial('property', propertyTemplate);
+    console.log(`✅ Registered property template: ${propertyTemplateFile}`);
+    
+    // Register topic property partial (choose cloud or regular version)
+    const topicPropertyTemplateFile = hasCloudSupport ? 'topic-property-cloud.hbs' : 'topic-property.hbs';
+    const topicPropertyTemplatePath = getTemplatePath(
+      path.join(templatesDir, topicPropertyTemplateFile),
+      'TEMPLATE_TOPIC_PROPERTY'
+    );
+    
+    if (!fs.existsSync(topicPropertyTemplatePath)) {
+      throw new Error(`Topic property template not found: ${topicPropertyTemplatePath}`);
+    }
+    
+    const topicPropertyTemplate = fs.readFileSync(topicPropertyTemplatePath, 'utf8');
+    handlebars.registerPartial('topic-property', topicPropertyTemplate);
+    console.log(`✅ Registered topic property template: ${topicPropertyTemplateFile}`);
+    
+    // Register deprecated property partial
+    const deprecatedPropertyTemplatePath = getTemplatePath(
+      path.join(templatesDir, 'deprecated-property.hbs'),
+      'TEMPLATE_DEPRECATED_PROPERTY'
+    );
+    
+    if (!fs.existsSync(deprecatedPropertyTemplatePath)) {
+      throw new Error(`Deprecated property template not found: ${deprecatedPropertyTemplatePath}`);
+    }
+    
+    const deprecatedPropertyTemplate = fs.readFileSync(deprecatedPropertyTemplatePath, 'utf8');
+    handlebars.registerPartial('deprecated-property', deprecatedPropertyTemplate);
+    console.log(`✅ Registered deprecated property template`);
+    
+  } catch (error) {
+    console.error('❌ Failed to register Handlebars templates:');
+    console.error(`   Error: ${error.message}`);
+    console.error('   This indicates missing or corrupted template files.');
+    console.error('   Check that all .hbs files exist in tools/property-extractor/templates/');
+    throw error;
+  }
 }
 
 /**
@@ -180,7 +233,17 @@ function generatePropertyDocs(properties, config, outputDir) {
 }
 
 /**
- * Generates deprecated properties documentation
+ * Generate an AsciiDoc fragment listing deprecated properties and write it to disk.
+ *
+ * Scans the provided properties map for entries with `is_deprecated === true`, groups
+ * them by `config_scope` ("broker" and "cluster"), sorts each group by property name,
+ * renders the `deprecated-properties` Handlebars template, and writes the output to
+ * `<outputDir>/deprecated/partials/deprecated-properties.adoc`.
+ *
+ * @param {Object.<string, Object>} properties - Map of property objects keyed by property name.
+ *   Each property object may contain `is_deprecated`, `config_scope`, and `name` fields.
+ * @param {string} outputDir - Destination directory where the deprecated fragment will be written.
+ * @returns {number} The total number of deprecated properties found and written.
  */
 function generateDeprecatedDocs(properties, outputDir) {
   const templatePath = getTemplatePath(
@@ -216,16 +279,51 @@ function generateDeprecatedDocs(properties, outputDir) {
 }
 
 /**
- * Main function to generate all property documentation
+ * Determine whether any property includes cloud support metadata.
+ *
+ * Checks the provided map of properties and returns true if at least one
+ * property object has a `cloud_supported` own property (regardless of its value).
+ *
+ * @param {Object<string, Object>} properties - Map from property name to its metadata object.
+ * @return {boolean} True if any property has a `cloud_supported` attribute; otherwise false.
  */
-function generateAllDocs(inputFile, outputDir) {
-  // Register partials
-  registerPartials();
+function hasCloudSupportMetadata(properties) {
+  return Object.values(properties).some(prop => 
+    Object.prototype.hasOwnProperty.call(prop, 'cloud_supported')
+  );
+}
 
+/**
+ * Generate all property documentation and write output files to disk.
+ *
+ * Reads properties from the provided JSON file, detects whether any property
+ * includes cloud support metadata to select cloud-aware templates, registers
+ * Handlebars partials accordingly, renders per-type property pages and a
+ * deprecated-properties partial, writes a flat list of all property names, and
+ * produces error reports.
+ *
+ * Generated artifacts are written under the given output directory (e.g.:
+ * pages/<type>/*.adoc, pages/deprecated/partials/deprecated-properties.adoc,
+ * all_properties.txt, and files under outputDir/error).
+ *
+ * @param {string} inputFile - Filesystem path to the input JSON containing a top-level `properties` object.
+ * @param {string} outputDir - Destination directory where generated pages and reports will be written.
+ * @returns {{totalProperties: number, brokerProperties: number, clusterProperties: number, objectStorageProperties: number, topicProperties: number, deprecatedProperties: number}} Summary counts for all properties and per-type totals.
+ */
+function generateAllDocs(inputFile, outputDir) {
   // Read input JSON
   const data = JSON.parse(fs.readFileSync(inputFile, 'utf8'));
   const properties = data.properties || {};
 
+  // Check if cloud support is enabled
+  const hasCloudSupport = hasCloudSupportMetadata(properties);
+  if (hasCloudSupport) {
+    console.log('🌤️ Cloud support metadata detected, using cloud-aware templates');
+  }
+
+  // Register partials with cloud support detection
+  registerPartials(hasCloudSupport);
+
   let totalProperties = 0;
   let totalBrokerProperties = 0;
   let totalClusterProperties = 0;
@@ -291,13 +389,15 @@ function generateErrorReports(properties, outputDir) {
   });
 
   // Write error reports
+  const totalProperties = Object.keys(properties).length;
+  
   if (emptyDescriptions.length > 0) {
     fs.writeFileSync(
       path.join(errorDir, 'empty_description.txt'),
       emptyDescriptions.join('\n'),
       'utf8'
     );
-    const percentage = ((emptyDescriptions.length / Object.keys(properties).length) * 100).toFixed(2);
+    const percentage = totalProperties > 0 ? ((emptyDescriptions.length / totalProperties) * 100).toFixed(2) : '0.00';
     console.log(`You have ${emptyDescriptions.length} properties with empty description. Percentage of errors: ${percentage}%. Data written in 'empty_description.txt'.`);
   }
 
@@ -307,7 +407,7 @@ function generateErrorReports(properties, outputDir) {
       deprecatedProperties.join('\n'),
       'utf8'
     );
-    const percentage = ((deprecatedProperties.length / Object.keys(properties).length) * 100).toFixed(2);
+    const percentage = totalProperties > 0 ? ((deprecatedProperties.length / totalProperties) * 100).toFixed(2) : '0.00';
     console.log(`You have ${deprecatedProperties.length} deprecated properties. Percentage of errors: ${percentage}%. Data written in 'deprecated_properties.txt'.`);
   }
 }

package/tools/property-extractor/parser.py

@@ -14,11 +14,37 @@ HEADER_QUERY = """
 ) @declaration
 """
 
+# Tree-sitter query for extracting C++ property constructor arguments and enterprise values
+#
+# - Enhanced to capture all expression types including:
+#   * call_expression: Handles function calls like model::kafka_audit_logging_topic()
+#   * template_instantiation: Handles template syntax like std::vector<ss::sstring>{...}
+#   * concatenated_string: Handles C++ string concatenation with +
+#   * qualified_identifier: Handles namespaced identifiers like model::partition_autobalancing_mode::continuous
+#   * (_) @argument: Fallback to capture any other expression types
+#
+# This ensures enterprise values are captured in their complete form for proper
+# processing by the process_enterprise_value function.
 SOURCE_QUERY = """
 (field_initializer_list
     (field_initializer
         (field_identifier) @field
-        (argument_list (_) @argument)? @arguments
+        (argument_list 
+            [
+                (call_expression) @argument
+                (initializer_list) @argument
+                (template_instantiation) @argument
+                (concatenated_string) @argument
+                (string_literal) @argument
+                (raw_string_literal) @argument
+                (identifier) @argument
+                (qualified_identifier) @argument
+                (number_literal) @argument
+                (true) @argument
+                (false) @argument
+                (_) @argument
+            ]
+        )? @arguments
     ) @field
 )
 """