@aifabrix/builder 2.31.0 → 2.32.1

package/lib/utils/cli-utils.js

@@ -38,31 +38,76 @@ function formatFormattedError(formatted) {
   return messages;
 }
 
+/**
+ * Checks if error is about Docker image not found
+ * @function isDockerImageNotFoundError
+ * @param {string} errorMsg - Error message
+ * @returns {boolean} True if Docker image not found error
+ */
+function isDockerImageNotFoundError(errorMsg) {
+  return errorMsg.includes('not found locally') ||
+    (errorMsg.includes('Docker image') && errorMsg.includes('not found'));
+}
+
+/**
+ * Checks if error is about Docker not running/installed
+ * @function isDockerNotRunningError
+ * @param {string} errorMsg - Error message
+ * @returns {boolean} True if Docker not running error
+ */
+function isDockerNotRunningError(errorMsg) {
+  return errorMsg.includes('Docker') &&
+    (errorMsg.includes('not running') || errorMsg.includes('not installed') || errorMsg.includes('Cannot connect'));
+}
+
+/**
+ * Checks if error is about port conflict
+ * @function isPortConflictError
+ * @param {string} errorMsg - Error message
+ * @returns {boolean} True if port conflict error
+ */
+function isPortConflictError(errorMsg) {
+  return errorMsg.toLowerCase().includes('port') &&
+    (errorMsg.includes('already in use') || errorMsg.includes('in use') || errorMsg.includes('conflict'));
+}
+
+/**
+ * Checks if error is about permission denied (excluding permissions field)
+ * @function isPermissionDeniedError
+ * @param {string} errorMsg - Error message
+ * @returns {boolean} True if permission denied error
+ */
+function isPermissionDeniedError(errorMsg) {
+  return (errorMsg.includes('permission denied') || errorMsg.includes('EACCES') || errorMsg.includes('Permission denied')) &&
+    !errorMsg.includes('permissions/') &&
+    !errorMsg.includes('Field "permissions');
+}
+
 /**
  * Format Docker-related errors
  * @param {string} errorMsg - Error message
  * @returns {string[]|null} Array of error message lines or null if not a Docker error
  */
 function formatDockerError(errorMsg) {
-  if (errorMsg.includes('not found locally') || (errorMsg.includes('Docker image') && errorMsg.includes('not found'))) {
+  if (isDockerImageNotFoundError(errorMsg)) {
     return [
       '   Docker image not found.',
       '   Run: aifabrix build <app> first'
     ];
   }
-  if (errorMsg.includes('Docker') && (errorMsg.includes('not running') || errorMsg.includes('not installed') || errorMsg.includes('Cannot connect'))) {
+  if (isDockerNotRunningError(errorMsg)) {
     return [
       '   Docker is not running or not installed.',
       '   Please start Docker Desktop and try again.'
     ];
   }
-  if (errorMsg.toLowerCase().includes('port') && (errorMsg.includes('already in use') || errorMsg.includes('in use') || errorMsg.includes('conflict'))) {
+  if (isPortConflictError(errorMsg)) {
     return [
       '   Port conflict detected.',
       '   Run "aifabrix doctor" to check which ports are in use.'
     ];
   }
-  if ((errorMsg.includes('permission denied') || errorMsg.includes('EACCES') || errorMsg.includes('Permission denied')) && !errorMsg.includes('permissions/') && !errorMsg.includes('Field "permissions')) {
+  if (isPermissionDeniedError(errorMsg)) {
     return [
       '   Permission denied.',
       '   Make sure you have the necessary permissions to run Docker commands.'
@@ -179,6 +224,31 @@ function formatValidationError(errorMsg) {
  * @param {Error} error - The error that occurred
  * @returns {string[]} Array of error message lines
  */
+/**
+ * Tries to format error using specific formatters
+ * @function tryFormatErrorWithFormatters
+ * @param {string} errorMsg - Error message
+ * @returns {string[]|null} Formatted error messages or null if no formatter matched
+ */
+function tryFormatErrorWithFormatters(errorMsg) {
+  const formatters = [
+    formatDockerError,
+    formatAzureError,
+    formatSecretsError,
+    formatDeploymentError,
+    formatValidationError
+  ];
+
+  for (const formatter of formatters) {
+    const formatted = formatter(errorMsg);
+    if (formatted) {
+      return formatted;
+    }
+  }
+
+  return null;
+}
+
 function formatError(error) {
   // If error has formatted message (from API error handler), use it directly
   if (error.formatted) {
@@ -186,37 +256,15 @@ function formatError(error) {
   }
 
   const errorMsg = error.message || '';
-  const messages = [];
 
   // Try different error formatters in order of specificity
-  const dockerError = formatDockerError(errorMsg);
-  if (dockerError) {
-    return dockerError;
-  }
-
-  const azureError = formatAzureError(errorMsg);
-  if (azureError) {
-    return azureError;
-  }
-
-  const secretsError = formatSecretsError(errorMsg);
-  if (secretsError) {
-    return secretsError;
-  }
-
-  const deploymentError = formatDeploymentError(errorMsg);
-  if (deploymentError) {
-    return deploymentError;
-  }
-
-  const validationError = formatValidationError(errorMsg);
-  if (validationError) {
-    return validationError;
+  const formatted = tryFormatErrorWithFormatters(errorMsg);
+  if (formatted) {
+    return formatted;
   }
 
   // Default: return generic error message
-  messages.push(`   ${errorMsg}`);
-  return messages;
+  return [`   ${errorMsg}`];
 }
 
 /**

package/lib/utils/compose-generator.js

@@ -13,7 +13,7 @@ const fsSync = require('fs');
 const fs = require('fs').promises;
 const path = require('path');
 const handlebars = require('handlebars');
-const config = require('../config');
+const config = require('../core/config');
 const buildCopy = require('./build-copy');
 
 // Register commonly used helpers
@@ -230,19 +230,26 @@ function buildNetworksConfig(config) {
  * @returns {Promise<Object>} Object with passwords array and lookup map
  * @throws {Error} If required password variables are missing
  */
-async function readDatabasePasswords(envPath, databases, appKey) {
-  const passwords = {};
-  const passwordsArray = [];
-
-  // Read .env file
-  const envVars = {};
+/**
+ * Reads and parses .env file
+ * @async
+ * @function readEnvFile
+ * @param {string} envPath - Path to .env file
+ * @returns {Promise<Object>} Object with environment variables
+ * @throws {Error} If file not found or read fails
+ */
+async function readEnvFile(envPath) {
   if (!fsSync.existsSync(envPath)) {
     throw new Error(`.env file not found: ${envPath}`);
   }
 
   try {
     const envContent = await fs.readFile(envPath, 'utf8');
+    if (envContent === undefined || envContent === null) {
+      throw new Error('Failed to read .env file: file content is empty or undefined');
+    }
     const lines = envContent.split('\n');
+    const envVars = {};
 
     for (const line of lines) {
       const trimmed = line.trim();
@@ -257,46 +264,97 @@ async function readDatabasePasswords(envPath, databases, appKey) {
         envVars[key] = value;
       }
     }
+
+    return envVars;
   } catch (error) {
     throw new Error(`Failed to read .env file: ${error.message}`);
   }
+}
 
-  // Process each database
-  if (databases && databases.length > 0) {
-    for (let i = 0; i < databases.length; i++) {
-      const db = databases[i];
-      const dbName = db.name || appKey;
-      const passwordKey = `DB_${i}_PASSWORD`;
-
-      if (!(passwordKey in envVars)) {
-        throw new Error(`Missing required password variable ${passwordKey} in .env file`);
-      }
+/**
+ * Validates and extracts password from environment variables
+ * @function extractPassword
+ * @param {Object} envVars - Environment variables
+ * @param {string} passwordKey - Password key to look up
+ * @returns {string} Password value
+ * @throws {Error} If password is missing or empty
+ */
+function extractPassword(envVars, passwordKey) {
+  if (!(passwordKey in envVars)) {
+    throw new Error(`Missing required password variable ${passwordKey} in .env file`);
+  }
 
-      const password = envVars[passwordKey].trim();
-      if (!password || password.length === 0) {
-        throw new Error(`Password variable ${passwordKey} is empty in .env file`);
-      }
+  const password = envVars[passwordKey].trim();
+  if (!password || password.length === 0) {
+    throw new Error(`Password variable ${passwordKey} is empty in .env file`);
+  }
 
-      passwords[dbName] = password;
-      passwordsArray.push(password);
-    }
-  } else {
-    // Single database case - use DB_0_PASSWORD or DB_PASSWORD
-    const passwordKey = ('DB_0_PASSWORD' in envVars) ? 'DB_0_PASSWORD' : 'DB_PASSWORD';
+  return password;
+}
 
-    if (!(passwordKey in envVars)) {
-      throw new Error(`Missing required password variable ${passwordKey} in .env file. Add DB_0_PASSWORD or DB_PASSWORD to your .env file.`);
-    }
+/**
+ * Processes multiple databases
+ * @function processMultipleDatabases
+ * @param {Array} databases - Array of database configurations
+ * @param {Object} envVars - Environment variables
+ * @param {string} appKey - Application key
+ * @returns {Object} Object with passwords map and array
+ */
+function processMultipleDatabases(databases, envVars, appKey) {
+  const passwords = {};
+  const passwordsArray = [];
 
-    const password = envVars[passwordKey].trim();
-    if (!password || password.length === 0) {
-      throw new Error(`Password variable ${passwordKey} is empty in .env file`);
-    }
+  for (let i = 0; i < databases.length; i++) {
+    const db = databases[i];
+    const dbName = db.name || appKey;
+    const passwordKey = `DB_${i}_PASSWORD`;
+    const password = extractPassword(envVars, passwordKey);
 
-    passwords[appKey] = password;
+    passwords[dbName] = password;
     passwordsArray.push(password);
   }
 
+  return { passwords, passwordsArray };
+}
+
+/**
+ * Processes single database case
+ * @function processSingleDatabase
+ * @param {Object} envVars - Environment variables
+ * @param {string} appKey - Application key
+ * @returns {Object} Object with passwords map and array
+ */
+function processSingleDatabase(envVars, appKey) {
+  const passwords = {};
+  const passwordsArray = [];
+
+  // Single database case - use DB_0_PASSWORD or DB_PASSWORD
+  const passwordKey = ('DB_0_PASSWORD' in envVars) ? 'DB_0_PASSWORD' : 'DB_PASSWORD';
+
+  if (!(passwordKey in envVars)) {
+    throw new Error(`Missing required password variable ${passwordKey} in .env file. Add DB_0_PASSWORD or DB_PASSWORD to your .env file.`);
+  }
+
+  const password = extractPassword(envVars, passwordKey);
+  passwords[appKey] = password;
+  passwordsArray.push(password);
+
+  return { passwords, passwordsArray };
+}
+
+async function readDatabasePasswords(envPath, databases, appKey) {
+  const envVars = await readEnvFile(envPath);
+
+  // Process each database
+  if (databases && databases.length > 0) {
+    const { passwords, passwordsArray } = processMultipleDatabases(databases, envVars, appKey);
+    return {
+      map: passwords,
+      array: passwordsArray
+    };
+  }
+
+  const { passwords, passwordsArray } = processSingleDatabase(envVars, appKey);
   return {
     map: passwords,
     array: passwordsArray
@@ -310,48 +368,71 @@ async function readDatabasePasswords(envPath, databases, appKey) {
  * @param {Object} options - Run options
  * @returns {Promise<string>} Generated compose content
  */
+/**
+ * Gets developer ID and calculates numeric ID
+ * @async
+ * @function getDeveloperIdAndNumeric
+ * @returns {Promise<Object>} Object with devId and idNum
+ */
+async function getDeveloperIdAndNumeric() {
+  const devId = await config.getDeveloperId();
+  const idNum = typeof devId === 'string' ? parseInt(devId, 10) : devId;
+  return { devId, idNum };
+}
+
+/**
+ * Builds network and container names
+ * @function buildNetworkAndContainerNames
+ * @param {string} appName - Application name
+ * @param {string|number} devId - Developer ID
+ * @param {number} idNum - Numeric developer ID
+ * @returns {Object} Object with networkName and containerName
+ */
+function buildNetworkAndContainerNames(appName, devId, idNum) {
+  const networkName = idNum === 0 ? 'infra-aifabrix-network' : `infra-dev${devId}-aifabrix-network`;
+  const containerName = idNum === 0 ? `aifabrix-${appName}` : `aifabrix-dev${devId}-${appName}`;
+  return { networkName, containerName };
+}
+
+/**
+ * Reads database passwords if needed
+ * @async
+ * @function readDatabasePasswordsIfNeeded
+ * @param {boolean} requiresDatabase - Whether database is required
+ * @param {Array} databases - Array of databases
+ * @param {string} envFilePath - Environment file path
+ * @param {string} appName - Application name
+ * @returns {Promise<Object>} Database passwords object
+ */
+async function readDatabasePasswordsIfNeeded(requiresDatabase, databases, envFilePath, appName) {
+  if (requiresDatabase || databases.length > 0) {
+    return await readDatabasePasswords(envFilePath, databases, appName);
+  }
+  return { map: {}, array: [] };
+}
+
 async function generateDockerCompose(appName, appConfig, options) {
   const language = appConfig.build?.language || appConfig.language || 'typescript';
   const template = loadDockerComposeTemplate(language);
-
-  // Use options.port if provided, otherwise use config.port
-  // (localPort will be handled in buildServiceConfig)
   const port = options.port || appConfig.port || 3000;
 
-  // Get developer ID and network name
-  const devId = await config.getDeveloperId();
-  const idNum = typeof devId === 'string' ? parseInt(devId, 10) : devId;
-  // Dev 0: infra-aifabrix-network (no dev-0 suffix)
-  // Dev > 0: infra-dev{id}-aifabrix-network
-  const networkName = idNum === 0 ? 'infra-aifabrix-network' : `infra-dev${devId}-aifabrix-network`;
-  // Dev 0: aifabrix-{appName} (no dev-0 suffix)
-  // Dev > 0: aifabrix-dev{id}-{appName}
-  const containerName = idNum === 0 ? `aifabrix-${appName}` : `aifabrix-dev${devId}-${appName}`;
+  const { devId, idNum } = await getDeveloperIdAndNumeric();
+  const { networkName, containerName } = buildNetworkAndContainerNames(appName, devId, idNum);
 
   const serviceConfig = buildServiceConfig(appName, appConfig, port);
   const volumesConfig = buildVolumesConfig(appName);
   const networksConfig = buildNetworksConfig(appConfig);
 
-  // Get absolute path to .env file for docker-compose (use dev-specific directory)
   const devDir = buildCopy.getDevDirectory(appName, devId);
   const envFilePath = path.join(devDir, '.env');
-  const envFileAbsolutePath = envFilePath.replace(/\\/g, '/'); // Use forward slashes for Docker
+  const envFileAbsolutePath = envFilePath.replace(/\\/g, '/');
 
-  // Read database passwords from .env file only if database is required
-  const databases = networksConfig.databases || [];
-  const requiresDatabase = serviceConfig.requiresDatabase || false;
-  let databasePasswords;
-
-  if (requiresDatabase || databases.length > 0) {
-    // Only read passwords if database is actually required
-    databasePasswords = await readDatabasePasswords(envFilePath, databases, appName);
-  } else {
-    // Return empty passwords when database is not required
-    databasePasswords = {
-      map: {},
-      array: []
-    };
-  }
+  const databasePasswords = await readDatabasePasswordsIfNeeded(
+    serviceConfig.requiresDatabase || false,
+    networksConfig.databases || [],
+    envFilePath,
+    appName
+  );
 
   const templateData = {
     ...serviceConfig,
@@ -359,7 +440,6 @@ async function generateDockerCompose(appName, appConfig, options) {
     ...networksConfig,
     envFile: envFileAbsolutePath,
     databasePasswords: databasePasswords,
-    // IMPORTANT: pass numeric devId to templates so (eq devId 0) works correctly
     devId: idNum,
     networkName: networkName,
     containerName: containerName

package/lib/utils/config-paths.js

@@ -107,6 +107,8 @@ function createPathConfigFunctions(getConfigFn, saveConfigFn) {
 }
 
 module.exports = {
+  getPathConfig,
+  setPathConfig,
   createPathConfigFunctions
 };
 

package/lib/utils/deployment-errors.js

@@ -8,7 +8,7 @@
  * @version 2.0.0
  */
 
-const auditLogger = require('../audit-logger');
+const auditLogger = require('../core/audit-logger');
 const { parseErrorResponse } = require('./api-error-handler');
 
 /**

package/lib/utils/device-code.js

@@ -146,41 +146,67 @@ function parseTokenResponse(response) {
  * @param {Object} response - Full API response object
  * @returns {Error} Validation error with formattedError and errorData attached
  */
-function createValidationError(response) {
-  const validationError = new Error('Token polling failed: Validation error');
-
-  // Attach formatted error if available (includes detailed validation info with ANSI colors)
+/**
+ * Attaches formatted error to validation error
+ * @function attachFormattedError
+ * @param {Error} validationError - Validation error object
+ * @param {Object} response - API response
+ */
+function attachFormattedError(validationError, response) {
   if (response && response.formattedError) {
     validationError.formattedError = response.formattedError;
     validationError.message = `Token polling failed:\n${response.formattedError}`;
   }
+}
+
+/**
+ * Builds detailed error message from error data
+ * @function buildDetailedErrorMessage
+ * @param {Object} errorData - Error data object
+ * @returns {string} Detailed error message
+ */
+function buildDetailedErrorMessage(errorData) {
+  const detail = errorData.detail || errorData.title || errorData.message || 'Validation error';
+  let errorMsg = `Token polling failed: ${detail}`;
+
+  if (errorData.errors && Array.isArray(errorData.errors) && errorData.errors.length > 0) {
+    errorMsg += '\n\nValidation errors:';
+    errorData.errors.forEach(err => {
+      const field = err.field || err.path || 'validation';
+      const message = err.message || 'Invalid value';
+      if (field === 'validation' || field === 'unknown') {
+        errorMsg += `\n  • ${message}`;
+      } else {
+        errorMsg += `\n  • ${field}: ${message}`;
+      }
+    });
+  }
+
+  return errorMsg;
+}
 
-  // Attach error data for programmatic access
+/**
+ * Attaches error data to validation error
+ * @function attachErrorData
+ * @param {Error} validationError - Validation error object
+ * @param {Object} response - API response
+ */
+function attachErrorData(validationError, response) {
   if (response && response.errorData) {
     validationError.errorData = response.errorData;
     validationError.errorType = response.errorType || 'validation';
 
-    // Build detailed message if formattedError not available
     if (!validationError.formattedError) {
-      const errorData = response.errorData;
-      const detail = errorData.detail || errorData.title || errorData.message || 'Validation error';
-      let errorMsg = `Token polling failed: ${detail}`;
-      // Add validation errors if available
-      if (errorData.errors && Array.isArray(errorData.errors) && errorData.errors.length > 0) {
-        errorMsg += '\n\nValidation errors:';
-        errorData.errors.forEach(err => {
-          const field = err.field || err.path || 'validation';
-          const message = err.message || 'Invalid value';
-          if (field === 'validation' || field === 'unknown') {
-            errorMsg += `\n  • ${message}`;
-          } else {
-            errorMsg += `\n  • ${field}: ${message}`;
-          }
-        });
-      }
-      validationError.message = errorMsg;
+      validationError.message = buildDetailedErrorMessage(response.errorData);
     }
   }
+}
+
+function createValidationError(response) {
+  const validationError = new Error('Token polling failed: Validation error');
+
+  attachFormattedError(validationError, response);
+  attachErrorData(validationError, response);
 
   return validationError;
 }
@@ -239,36 +265,69 @@ async function waitForNextPoll(interval, slowDown) {
  * @param {Object} response - API response object
  * @returns {string} Error code or 'Unknown error'
  */
-function extractPollingError(response) {
-  // Check for structured error data first (from api-error-handler)
-  if (response.errorData) {
-    const errorData = response.errorData;
-    // For validation errors, return the error type so we can handle it specially
-    if (response.errorType === 'validation') {
-      return 'validation_error';
-    }
-    // Check if error code indicates validation error (e.g., INVALID_TOKEN)
-    const errorCode = errorData.error || errorData.code || response.error;
-    if (errorCode === 'INVALID_TOKEN' || errorCode === 'INVALID_ACCESS_TOKEN') {
-      return 'validation_error';
-    }
-    // Return the error message from structured error
-    return errorData.detail || errorData.title || errorData.message || errorCode || response.error || 'Unknown error';
+/**
+ * Checks if error code indicates validation error
+ * @function isValidationErrorCode
+ * @param {string} errorCode - Error code to check
+ * @returns {boolean} True if validation error
+ */
+function isValidationErrorCode(errorCode) {
+  return errorCode === 'INVALID_TOKEN' || errorCode === 'INVALID_ACCESS_TOKEN';
+}
+
+/**
+ * Extracts error from structured error data
+ * @function extractStructuredError
+ * @param {Object} response - API response with errorData
+ * @returns {string} Error message or code
+ */
+function extractStructuredError(response) {
+  const errorData = response.errorData;
+
+  // For validation errors, return the error type so we can handle it specially
+  if (response.errorType === 'validation') {
+    return 'validation_error';
   }
 
-  // Fallback to original extraction logic
+  // Check if error code indicates validation error (e.g., INVALID_TOKEN)
+  const errorCode = errorData.error || errorData.code || response.error;
+  if (isValidationErrorCode(errorCode)) {
+    return 'validation_error';
+  }
+
+  // Return the error message from structured error
+  return errorData.detail || errorData.title || errorData.message || errorCode || response.error || 'Unknown error';
+}
+
+/**
+ * Extracts error from fallback response structure
+ * @function extractFallbackError
+ * @param {Object} response - API response
+ * @returns {string} Error code
+ */
+function extractFallbackError(response) {
   const apiResponse = response.data || {};
   const errorData = typeof apiResponse === 'object' ? apiResponse : {};
   const errorCode = errorData.error || response.error || 'Unknown error';
 
   // Check if error code indicates validation error (e.g., INVALID_TOKEN)
-  if (errorCode === 'INVALID_TOKEN' || errorCode === 'INVALID_ACCESS_TOKEN') {
+  if (isValidationErrorCode(errorCode)) {
     return 'validation_error';
   }
 
   return errorCode;
 }
 
+function extractPollingError(response) {
+  // Check for structured error data first (from api-error-handler)
+  if (response.errorData) {
+    return extractStructuredError(response);
+  }
+
+  // Fallback to original extraction logic
+  return extractFallbackError(response);
+}
+
 /**
  * Handles successful polling response
  * @param {Object} response - API response object
@@ -439,4 +498,3 @@ module.exports = {
   refreshDeviceToken,
   parseTokenResponse
 };
-

package/lib/utils/env-config-loader.js

@@ -12,7 +12,7 @@
 const fs = require('fs');
 const path = require('path');
 const yaml = require('js-yaml');
-const config = require('../config');
+const config = require('../core/config');
 
 /**
  * Loads user env-config file if configured