@aifabrix/builder 2.31.1 → 2.32.1

package/lib/{diff.js → core/diff.js}

@@ -12,7 +12,7 @@
 const fs = require('fs');
 const path = require('path');
 const chalk = require('chalk');
-const logger = require('./utils/logger');
+const logger = require('../utils/logger');
 
 /**
  * Handle added field in comparison
@@ -83,6 +83,37 @@ function isNestedObject(value) {
  * @param {string} [path=''] - Current path in object (for nested fields)
  * @returns {Object} Comparison result with added, removed, changed fields
  */
+/**
+ * Compares a single key between two objects
+ * @function compareSingleKey
+ * @param {string} key - Key to compare
+ * @param {Object} obj1 - First object
+ * @param {Object} obj2 - Second object
+ * @param {string} newPath - Current path in object
+ * @param {Object} result - Comparison result object
+ */
+function compareSingleKey(key, obj1, obj2, newPath, result) {
+  const val1 = obj1 && obj1[key];
+  const val2 = obj2 && obj2[key];
+
+  if (!(key in obj1)) {
+    handleAddedField(key, val2, newPath, result);
+  } else if (!(key in obj2)) {
+    handleRemovedField(key, val1, newPath, result);
+  } else if (isNestedObject(val1) && isNestedObject(val2)) {
+    // Recursively compare nested objects
+    const nestedResult = compareObjects(val1, val2, newPath);
+    result.added.push(...nestedResult.added);
+    result.removed.push(...nestedResult.removed);
+    result.changed.push(...nestedResult.changed);
+    if (!nestedResult.identical) {
+      result.identical = false;
+    }
+  } else if (JSON.stringify(val1) !== JSON.stringify(val2)) {
+    handleChangedField(val1, val2, newPath, result);
+  }
+}
+
 function compareObjects(obj1, obj2, currentPath = '') {
   const result = {
     added: [],
@@ -95,25 +126,7 @@ function compareObjects(obj1, obj2, currentPath = '') {
 
   for (const key of allKeys) {
     const newPath = currentPath ? `${currentPath}.${key}` : key;
-    const val1 = obj1 && obj1[key];
-    const val2 = obj2 && obj2[key];
-
-    if (!(key in obj1)) {
-      handleAddedField(key, val2, newPath, result);
-    } else if (!(key in obj2)) {
-      handleRemovedField(key, val1, newPath, result);
-    } else if (isNestedObject(val1) && isNestedObject(val2)) {
-      // Recursively compare nested objects
-      const nestedResult = compareObjects(val1, val2, newPath);
-      result.added.push(...nestedResult.added);
-      result.removed.push(...nestedResult.removed);
-      result.changed.push(...nestedResult.changed);
-      if (!nestedResult.identical) {
-        result.identical = false;
-      }
-    } else if (JSON.stringify(val1) !== JSON.stringify(val2)) {
-      handleChangedField(val1, val2, newPath, result);
-    }
+    compareSingleKey(key, obj1, obj2, newPath, result);
   }
 
   return result;
@@ -170,49 +183,68 @@ function identifyBreakingChanges(comparison) {
  * const result = await compareFiles('./old.json', './new.json');
  * // Returns: { identical: false, added: [...], removed: [...], changed: [...] }
  */
-async function compareFiles(file1, file2) {
+/**
+ * Validates file paths
+ * @function validateFilePaths
+ * @param {string} file1 - First file path
+ * @param {string} file2 - Second file path
+ * @throws {Error} If paths are invalid
+ */
+function validateFilePaths(file1, file2) {
   if (!file1 || typeof file1 !== 'string') {
     throw new Error('First file path is required');
   }
   if (!file2 || typeof file2 !== 'string') {
     throw new Error('Second file path is required');
   }
-
-  // Validate files exist
   if (!fs.existsSync(file1)) {
     throw new Error(`File not found: ${file1}`);
   }
   if (!fs.existsSync(file2)) {
     throw new Error(`File not found: ${file2}`);
   }
+}
 
-  // Read and parse files
-  let content1, content2;
-  let parsed1, parsed2;
-
-  try {
-    content1 = fs.readFileSync(file1, 'utf8');
-    parsed1 = JSON.parse(content1);
-  } catch (error) {
-    throw new Error(`Failed to parse ${file1}: ${error.message}`);
-  }
-
+/**
+ * Reads and parses a JSON file
+ * @function readAndParseFile
+ * @param {string} filePath - File path
+ * @returns {Object} Parsed JSON object
+ * @throws {Error} If file cannot be read or parsed
+ */
+function readAndParseFile(filePath) {
   try {
-    content2 = fs.readFileSync(file2, 'utf8');
-    parsed2 = JSON.parse(content2);
+    const content = fs.readFileSync(filePath, 'utf8');
+    return JSON.parse(content);
   } catch (error) {
-    throw new Error(`Failed to parse ${file2}: ${error.message}`);
+    throw new Error(`Failed to parse ${filePath}: ${error.message}`);
   }
+}
 
-  // Compare objects
-  const comparison = compareObjects(parsed1, parsed2);
+/**
+ * Extracts version from parsed object
+ * @function extractVersion
+ * @param {Object} parsed - Parsed JSON object
+ * @returns {string} Version string
+ */
+function extractVersion(parsed) {
+  return parsed.version || parsed.metadata?.version || 'unknown';
+}
 
-  // Check for version changes
-  const version1 = parsed1.version || parsed1.metadata?.version || 'unknown';
-  const version2 = parsed2.version || parsed2.metadata?.version || 'unknown';
+/**
+ * Builds comparison result object
+ * @function buildComparisonResult
+ * @param {Object} comparison - Comparison result from compareObjects
+ * @param {Object} parsed1 - First parsed object
+ * @param {Object} parsed2 - Second parsed object
+ * @param {string} file1 - First file path
+ * @param {string} file2 - Second file path
+ * @returns {Object} Complete comparison result
+ */
+function buildComparisonResult(comparison, parsed1, parsed2, file1, file2) {
+  const version1 = extractVersion(parsed1);
+  const version2 = extractVersion(parsed2);
   const versionChanged = version1 !== version2;
-
-  // Identify breaking changes
   const breakingChanges = identifyBreakingChanges(comparison);
 
   return {
@@ -235,6 +267,16 @@ async function compareFiles(file1, file2) {
   };
 }
 
+async function compareFiles(file1, file2) {
+  validateFilePaths(file1, file2);
+
+  const parsed1 = readAndParseFile(file1);
+  const parsed2 = readAndParseFile(file2);
+
+  const comparison = compareObjects(parsed1, parsed2);
+  return buildComparisonResult(comparison, parsed1, parsed2, file1, file2);
+}
+
 /**
  * Formats and displays diff output
  * Shows differences in a user-friendly format with color coding
@@ -242,61 +284,104 @@ async function compareFiles(file1, file2) {
  * @function formatDiffOutput
  * @param {Object} diffResult - Comparison result from compareFiles
  */
-function formatDiffOutput(diffResult) {
-  logger.log(chalk.blue(`\nComparing: ${diffResult.file1} ↔ ${diffResult.file2}`));
-
-  if (diffResult.identical) {
-    logger.log(chalk.green('\n✓ Files are identical'));
-    return;
-  }
-
-  logger.log(chalk.yellow('\nFiles are different'));
-
-  // Version information
+/**
+ * Displays version information if changed
+ * @function displayVersionInfo
+ * @param {Object} diffResult - Comparison result
+ */
+function displayVersionInfo(diffResult) {
   if (diffResult.versionChanged) {
     logger.log(chalk.blue(`\nVersion: ${diffResult.version1} → ${diffResult.version2}`));
   }
+}
 
-  // Breaking changes
-  if (diffResult.breakingChanges.length > 0) {
+/**
+ * Displays breaking changes
+ * @function displayBreakingChanges
+ * @param {Object[]} breakingChanges - Array of breaking changes
+ */
+function displayBreakingChanges(breakingChanges) {
+  if (breakingChanges.length > 0) {
     logger.log(chalk.red('\n⚠️  Breaking Changes:'));
-    diffResult.breakingChanges.forEach(change => {
+    breakingChanges.forEach(change => {
       logger.log(chalk.red(`  • ${change.description}`));
     });
   }
+}
 
-  // Added fields
-  if (diffResult.added.length > 0) {
+/**
+ * Displays added fields
+ * @function displayAddedFields
+ * @param {Object[]} added - Array of added fields
+ */
+function displayAddedFields(added) {
+  if (added.length > 0) {
     logger.log(chalk.green('\nAdded Fields:'));
-    diffResult.added.forEach(field => {
+    added.forEach(field => {
       logger.log(chalk.green(`  + ${field.path}: ${JSON.stringify(field.value)}`));
     });
   }
+}
 
-  // Removed fields
-  if (diffResult.removed.length > 0) {
+/**
+ * Displays removed fields
+ * @function displayRemovedFields
+ * @param {Object[]} removed - Array of removed fields
+ */
+function displayRemovedFields(removed) {
+  if (removed.length > 0) {
     logger.log(chalk.red('\nRemoved Fields:'));
-    diffResult.removed.forEach(field => {
+    removed.forEach(field => {
       logger.log(chalk.red(`  - ${field.path}: ${JSON.stringify(field.value)}`));
     });
   }
+}
 
-  // Changed fields
-  if (diffResult.changed.length > 0) {
+/**
+ * Displays changed fields
+ * @function displayChangedFields
+ * @param {Object[]} changed - Array of changed fields
+ */
+function displayChangedFields(changed) {
+  if (changed.length > 0) {
     logger.log(chalk.yellow('\nChanged Fields:'));
-    diffResult.changed.forEach(change => {
+    changed.forEach(change => {
       logger.log(chalk.yellow(`  ~ ${change.path}:`));
       logger.log(chalk.gray(`    Old: ${JSON.stringify(change.oldValue)}`));
       logger.log(chalk.gray(`    New: ${JSON.stringify(change.newValue)}`));
     });
   }
+}
 
-  // Summary
+/**
+ * Displays summary statistics
+ * @function displaySummary
+ * @param {Object} summary - Summary object
+ */
+function displaySummary(summary) {
   logger.log(chalk.blue('\nSummary:'));
-  logger.log(chalk.blue(`  Added: ${diffResult.summary.totalAdded}`));
-  logger.log(chalk.blue(`  Removed: ${diffResult.summary.totalRemoved}`));
-  logger.log(chalk.blue(`  Changed: ${diffResult.summary.totalChanged}`));
-  logger.log(chalk.blue(`  Breaking: ${diffResult.summary.totalBreaking}`));
+  logger.log(chalk.blue(`  Added: ${summary.totalAdded}`));
+  logger.log(chalk.blue(`  Removed: ${summary.totalRemoved}`));
+  logger.log(chalk.blue(`  Changed: ${summary.totalChanged}`));
+  logger.log(chalk.blue(`  Breaking: ${summary.totalBreaking}`));
+}
+
+function formatDiffOutput(diffResult) {
+  logger.log(chalk.blue(`\nComparing: ${diffResult.file1} ↔ ${diffResult.file2}`));
+
+  if (diffResult.identical) {
+    logger.log(chalk.green('\n✓ Files are identical'));
+    return;
+  }
+
+  logger.log(chalk.yellow('\nFiles are different'));
+
+  displayVersionInfo(diffResult);
+  displayBreakingChanges(diffResult.breakingChanges);
+  displayAddedFields(diffResult.added);
+  displayRemovedFields(diffResult.removed);
+  displayChangedFields(diffResult.changed);
+  displaySummary(diffResult.summary);
 }
 
 module.exports = {

package/lib/{secrets.js → core/secrets.js}

@@ -12,7 +12,7 @@
 const fs = require('fs');
 const path = require('path');
 const yaml = require('js-yaml');
-const logger = require('./utils/logger');
+const logger = require('../utils/logger');
 const config = require('./config');
 const {
   interpolateEnvVars,
@@ -26,24 +26,24 @@ const {
   applyCanonicalSecretsOverride,
   ensureNonEmptySecrets,
   validateSecrets
-} = require('./utils/secrets-helpers');
-const { processEnvVariables } = require('./utils/env-copy');
-const { buildEnvVarMap } = require('./utils/env-map');
-const { resolveServicePortsInEnvContent } = require('./utils/secrets-url');
+} = require('../utils/secrets-helpers');
+const { processEnvVariables } = require('../utils/env-copy');
+const { buildEnvVarMap } = require('../utils/env-map');
+const { resolveServicePortsInEnvContent } = require('../utils/secrets-url');
 const {
   generateMissingSecrets,
   createDefaultSecrets
-} = require('./utils/secrets-generator');
+} = require('../utils/secrets-generator');
 const {
   resolveSecretsPath,
   getActualSecretsPath
-} = require('./utils/secrets-path');
+} = require('../utils/secrets-path');
 const {
   loadUserSecrets,
   loadDefaultSecrets
-} = require('./utils/secrets-utils');
-const { decryptSecret, isEncrypted } = require('./utils/secrets-encryption');
-const pathsUtil = require('./utils/paths');
+} = require('../utils/secrets-utils');
+const { decryptSecret, isEncrypted } = require('../utils/secrets-encryption');
+const pathsUtil = require('../utils/paths');
 
 /**
  * Generates a canonical secret name from an environment variable key.
@@ -58,7 +58,10 @@ function getCanonicalSecretName(key) {
   if (!key || typeof key !== 'string') {
     return '';
   }
-  const lower = key.toLowerCase();
+  // Insert hyphens before capital letters (camelCase -> kebab-case)
+  // Then convert to lowercase and replace non-alphanumeric with hyphens
+  const withHyphens = key.replace(/([a-z0-9])([A-Z])/g, '$1-$2');
+  const lower = withHyphens.toLowerCase();
   const hyphenated = lower.replace(/[^a-z0-9]/g, '-');
   const collapsed = hyphenated.replace(/-+/g, '-');
   return collapsed.replace(/^-+|-+$/g, '');
@@ -217,21 +220,23 @@ async function resolveKvReferences(envTemplate, secrets, environment = 'local',
  * // Returns: './builder/myapp/.env'
  */
 /**
- * Updates PORT in resolved content for docker environment
- * Sets PORT to container port (build.containerPort or port from variables.yaml)
- * NOT the host port (which includes developer-id offset)
+ * Gets base docker environment config
  * @async
- * @function updatePortForDocker
- * @param {string} resolved - Resolved environment content
- * @param {string} variablesPath - Path to variables.yaml file
- * @returns {Promise<string>} Updated content with PORT set
+ * @function getBaseDockerEnv
+ * @returns {Promise<Object>} Docker environment config
  */
-async function updatePortForDocker(resolved, variablesPath) {
-  // Step 1: Get base config from env-config.yaml (includes user env-config file if configured)
-  const { getEnvHosts } = require('./utils/env-endpoints');
-  let dockerEnv = await getEnvHosts('docker');
+async function getBaseDockerEnv() {
+  const { getEnvHosts } = require('../utils/env-endpoints');
+  return await getEnvHosts('docker');
+}
 
-  // Step 2: Apply config.yaml → environments.docker override (if exists)
+/**
+ * Applies config.yaml override to docker environment
+ * @function applyDockerEnvOverride
+ * @param {Object} dockerEnv - Base docker environment config
+ * @returns {Object} Updated docker environment config
+ */
+function applyDockerEnvOverride(dockerEnv) {
   try {
     const os = require('os');
     const cfgPath = path.join(os.homedir(), '.aifabrix', 'config.yaml');
@@ -239,38 +244,70 @@ async function updatePortForDocker(resolved, variablesPath) {
       const cfgContent = fs.readFileSync(cfgPath, 'utf8');
       const cfg = yaml.load(cfgContent) || {};
       if (cfg && cfg.environments && cfg.environments.docker) {
-        dockerEnv = { ...dockerEnv, ...cfg.environments.docker };
+        return { ...dockerEnv, ...cfg.environments.docker };
       }
     }
   } catch {
     // Ignore config.yaml read errors, continue with env-config values
   }
+  return dockerEnv;
+}
+
+/**
+ * Gets container port from variables.yaml
+ * @function getContainerPortFromVariables
+ * @param {string} variablesPath - Path to variables.yaml
+ * @returns {number|null} Container port or null
+ */
+function getContainerPortFromVariables(variablesPath) {
+  if (!variablesPath || !fs.existsSync(variablesPath)) {
+    return null;
+  }
+  try {
+    const variablesContent = fs.readFileSync(variablesPath, 'utf8');
+    const variables = yaml.load(variablesContent);
+    // Use containerPort if specified, otherwise use base port (no developer-id offset)
+    return variables?.build?.containerPort || variables?.port || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Gets container port from docker environment config
+ * @function getContainerPortFromDockerEnv
+ * @param {Object} dockerEnv - Docker environment config
+ * @returns {number} Container port (defaults to 3000)
+ */
+function getContainerPortFromDockerEnv(dockerEnv) {
+  if (dockerEnv.PORT === undefined || dockerEnv.PORT === null) {
+    return 3000;
+  }
+  const portVal = typeof dockerEnv.PORT === 'number' ? dockerEnv.PORT : parseInt(dockerEnv.PORT, 10);
+  return Number.isNaN(portVal) ? 3000 : portVal;
+}
+
+/**
+ * Updates PORT in resolved content for docker environment
+ * Sets PORT to container port (build.containerPort or port from variables.yaml)
+ * NOT the host port (which includes developer-id offset)
+ * @async
+ * @function updatePortForDocker
+ * @param {string} resolved - Resolved environment content
+ * @param {string} variablesPath - Path to variables.yaml file
+ * @returns {Promise<string>} Updated content with PORT set
+ */
+async function updatePortForDocker(resolved, variablesPath) {
+  // Step 1: Get base config from env-config.yaml
+  let dockerEnv = await getBaseDockerEnv();
+
+  // Step 2: Apply config.yaml → environments.docker override (if exists)
+  dockerEnv = applyDockerEnvOverride(dockerEnv);
 
   // Step 3: Get PORT value for container (should be container port, NOT host port)
-  // For Docker containers, PORT should be the container port (build.containerPort or port)
-  // NOT the host port (which includes developer-id offset)
-  let containerPort = null;
-  if (variablesPath && fs.existsSync(variablesPath)) {
-    try {
-      const variablesContent = fs.readFileSync(variablesPath, 'utf8');
-      const variables = yaml.load(variablesContent);
-      // Use containerPort if specified, otherwise use base port (no developer-id offset)
-      containerPort = variables?.build?.containerPort || variables?.port || 3000;
-    } catch {
-      // Fallback to default
-      containerPort = 3000;
-    }
-  } else {
-    // Fallback: check dockerEnv.PORT (but this should be container port, not host port)
-    if (dockerEnv.PORT !== undefined && dockerEnv.PORT !== null) {
-      const portVal = typeof dockerEnv.PORT === 'number' ? dockerEnv.PORT : parseInt(dockerEnv.PORT, 10);
-      if (!Number.isNaN(portVal)) {
-        containerPort = portVal;
-      }
-    }
-    if (containerPort === null || containerPort === undefined) {
-      containerPort = 3000;
-    }
+  let containerPort = getContainerPortFromVariables(variablesPath);
+  if (containerPort === null) {
+    containerPort = getContainerPortFromDockerEnv(dockerEnv);
   }
 
   // PORT in container should be the container port (no developer-id adjustment)
@@ -294,7 +331,7 @@ async function applyEnvironmentTransformations(resolved, environment, variablesP
     // Interpolate ${VAR} references created by rewriteInfraEndpoints
     // Get the actual host and port values from env-endpoints.js directly
     // to ensure they are correctly populated in envVars for interpolation
-    const { getEnvHosts, getServiceHost, getServicePort, getLocalhostOverride } = require('./utils/env-endpoints');
+    const { getEnvHosts, getServiceHost, getServicePort, getLocalhostOverride } = require('../utils/env-endpoints');
     const hosts = await getEnvHosts('docker');
     const localhostOverride = getLocalhostOverride('docker');
     const redisHost = getServiceHost(hosts.REDIS_HOST, 'docker', 'redis', localhostOverride);