@aifabrix/builder 2.39.1 → 2.39.2

package/lib/app/readme.js

@@ -12,6 +12,7 @@ const fs = require('fs').promises;
 const fsSync = require('fs');
 const path = require('path');
 const handlebars = require('handlebars');
+const yaml = require('js-yaml');
 const { generateExternalReadmeContent } = require('../utils/external-readme');
 
 /**
@@ -158,28 +159,69 @@ function generateReadmeMd(appName, config) {
 }
 
 /**
- * Generates README.md file if it doesn't exist
+ * Generates README.md file (optionally only if missing)
  * @async
  * @function generateReadmeMdFile
  * @param {string} appPath - Path to application directory
  * @param {string} appName - Application name
- * @param {Object} config - Application configuration
+ * @param {Object} config - Application configuration (e.g. from variables.yaml)
+ * @param {Object} [options] - Options
+ * @param {boolean} [options.force] - If true, overwrite existing README.md (dynamic generation)
  * @returns {Promise<void>} Resolves when README.md is generated or skipped
  * @throws {Error} If file generation fails
  */
-async function generateReadmeMdFile(appPath, appName, config) {
-  // Ensure directory exists
+async function generateReadmeMdFile(appPath, appName, config, options = {}) {
   await fs.mkdir(appPath, { recursive: true });
   const readmePath = path.join(appPath, 'README.md');
-  if (!(await fileExists(readmePath))) {
-    const readmeContent = generateReadmeMd(appName, config);
-    await fs.writeFile(readmePath, readmeContent, 'utf8');
+  if (!options.force && (await fileExists(readmePath))) {
+    return;
+  }
+  const readmeContent = generateReadmeMd(appName, config);
+  await fs.writeFile(readmePath, readmeContent, 'utf8');
+}
+
+/**
+ * Loads variables.yaml from app path and generates README.md (overwrites if present).
+ * Used when copying template apps or running up-miso / up-platform / up-dataplane.
+ * @async
+ * @function ensureReadmeForAppPath
+ * @param {string} appPath - Path to application directory (must contain variables.yaml)
+ * @param {string} appName - Application name
+ * @returns {Promise<void>} Resolves when README.md is written or skipped (no variables.yaml)
+ */
+async function ensureReadmeForAppPath(appPath, appName) {
+  const variablesPath = path.join(appPath, 'variables.yaml');
+  if (!(await fileExists(variablesPath))) {
+    return;
+  }
+  const content = await fs.readFile(variablesPath, 'utf8');
+  const config = yaml.load(content) || {};
+  await generateReadmeMdFile(appPath, appName, config, { force: true });
+}
+
+/**
+ * Generates README.md for an app at builder path(s): primary and cwd/builder if different.
+ * Use after ensureAppFromTemplate in up-miso / up-dataplane so README reflects current config.
+ * @async
+ * @function ensureReadmeForApp
+ * @param {string} appName - Application name (e.g. keycloak, miso-controller, dataplane)
+ * @returns {Promise<void>}
+ */
+async function ensureReadmeForApp(appName) {
+  const pathsUtil = require('../utils/paths');
+  const primaryPath = pathsUtil.getBuilderPath(appName);
+  await ensureReadmeForAppPath(primaryPath, appName);
+  const cwdBuilderPath = path.join(process.cwd(), 'builder', appName);
+  if (path.resolve(cwdBuilderPath) !== path.resolve(primaryPath)) {
+    await ensureReadmeForAppPath(cwdBuilderPath, appName);
   }
 }
 
 module.exports = {
   generateReadmeMdFile,
   generateReadmeMd,
-  formatAppDisplayName
+  formatAppDisplayName,
+  ensureReadmeForAppPath,
+  ensureReadmeForApp
 };
 

package/lib/commands/up-common.js

@@ -15,9 +15,11 @@ const chalk = require('chalk');
 const logger = require('../utils/logger');
 const pathsUtil = require('../utils/paths');
 const { copyTemplateFiles } = require('../validation/template');
+const { ensureReadmeForAppPath, ensureReadmeForApp } = require('../app/readme');
 
 /**
  * Copy template to a target path if variables.yaml is missing there.
+ * After copy, generates README.md from templates/applications/README.md.hbs.
  * @param {string} appName - Application name
  * @param {string} targetAppPath - Target directory (e.g. builder/keycloak)
  * @returns {Promise<boolean>} True if template was copied, false if already present
@@ -28,6 +30,7 @@ async function ensureTemplateAtPath(appName, targetAppPath) {
     return false;
   }
   await copyTemplateFiles(appName, targetAppPath);
+  await ensureReadmeForAppPath(targetAppPath, appName);
   return true;
 }
 
@@ -160,6 +163,7 @@ async function ensureAppFromTemplate(appName) {
     }
   }
 
+  await ensureReadmeForApp(appName);
   return primaryCopied;
 }
 

package/lib/external-system/generator.js

@@ -35,13 +35,19 @@ async function generateExternalSystemTemplate(appPath, systemKey, config) {
     const templateContent = await fs.readFile(templatePath, 'utf8');
     const template = handlebars.compile(templateContent);
 
+    const roles = (config.roles || null) && config.roles.map((role) => ({
+      ...role,
+      groups: role.groups || role.Groups || undefined
+    }));
+
     const context = {
       systemKey: systemKey,
       systemDisplayName: config.systemDisplayName || systemKey.replace(/-/g, ' ').replace(/\b\w/g, l => l.toUpperCase()),
       systemDescription: config.systemDescription || `External system integration for ${systemKey}`,
       systemType: config.systemType || 'openapi',
       authType: config.authType || 'apikey',
-      roles: config.roles || null,
+      baseUrl: config.baseUrl || null,
+      roles: roles || null,
       permissions: config.permissions || null
     };
 
@@ -74,6 +80,8 @@ async function generateExternalDataSourceTemplate(appPath, datasourceKey, config
     const templateContent = await fs.readFile(templatePath, 'utf8');
     const template = handlebars.compile(templateContent);
 
+    const dimensions = config.dimensions || {};
+    const attributes = config.attributes || {};
     const context = {
       datasourceKey: datasourceKey,
       datasourceDisplayName: config.datasourceDisplayName || datasourceKey.replace(/-/g, ' ').replace(/\b\w/g, l => l.toUpperCase()),
@@ -82,8 +90,11 @@ async function generateExternalDataSourceTemplate(appPath, datasourceKey, config
       entityType: config.entityType || datasourceKey.split('-').pop(),
       resourceType: config.resourceType || 'document',
       systemType: config.systemType || 'openapi',
-      dimensions: config.dimensions || {},
-      attributes: config.attributes || {}
+      // Pass non-empty objects so template uses custom block; empty/null so template uses schema-valid defaults
+      dimensions: Object.keys(dimensions).length > 0 ? dimensions : null,
+      attributes: Object.keys(attributes).length > 0 ? attributes : null,
+      // Literal expression strings for default attribute block (schema: pipe-based DSL {{raw.path}})
+      raw: { id: '{{raw.id}}', name: '{{raw.name}}' }
     };
 
     const rendered = template(context);